Derived Types

One column's values: a kind discriminator, one active storage array, sparse validity, an optional unit, and the row/width geometry.

Column-level schema state for one MAML: an array of parquet_column_type, one per declared field, plus lookups/toggles over it. Embedded in parquet_schema%cinfo; parquet_schema's own type-bound procedures are flat passthroughs to the ones here.

One schema field's write-time metadata and QC bounds, parsed from a MAML fields: entry (or built via schema%add_field); one array element per field, held in parquet_column_info%col(:).

A calendar date (proleptic Gregorian), stored as days since 1970-01-01 -- identical to the physical value of a Parquet DATE / Arrow date32 column. A default-initialized element is null. Range: about +-5.8 million years.

A row filter for parquet_open_reader/parquet_reader_set_filter: each %add call contributes one boolean expression over the file's columns, and several %add calls are AND-combined, i.e. (expr1) and (expr2). One expression is either a single clause, " [value]" (e.g. "ra > 180", "id is_not_null"), or clauses combined with and/or/not and parentheses, e.g. "(ra > 180 and dec <= 0) or id is_null". Keywords are case-insensitive and bind not > and > or. Null rows follow SQL's three-valued logic: a comparison against a Null is unknown, unknown never survives, and is_null/is_not_null are the only way to select on nullness. A NaN is a value, not a Null: it compares false against >, >=, <, <= and ==, so it survives /= and any negated comparison; is_nan/is_not_nan (floating-point columns only) select on it directly. Rules are unvalidated here -- the expression is parsed, and every clause validated (column exists, is a scalar column, value is well-formed for that column's type), once a reader actually applies the filter. See "Row filtering with parquet_filter" in doc/pages/io/filter-sort-sample.md for the grammar.

One col_map: entry: - <internal_name>: <output_name>, i.e. the field declared as output_name in this MAML fields: actually corresponds to the internal/canonical column named internal_name.

One embedded or user-supplied MAML file: its raw source lines plus, once parsed/validated, the columns missing relative to the base schema and any col_map: renames it declares. add_col_qc/set_col_qc build a qc-maml incrementally (see parquet_maml_base_add_col_qc.f90).

One schema field the base MAML declares but a user-supplied MAML omits; populated by parquet_validate_user_maml, one entry per missing field.

Read-time quality control declared in CODE rather than in a MAML file: one column per %add call, in exactly the compact "col, min, max, miss" string parquet_schema%add_col_qc already takes, so there is one read-time-QC grammar in this library rather than two. See "Building a qc-maml in code" in doc/pages/schema/quality-control.md for the field syntax -- the operator prefixes (>, >=, <, <=) and the Null/NA/empty miss: convention are inherited from %add_col_qc verbatim.

Opaque handle for an open parquet file being read; see parquet_writer's doc comment above for the shared handle-ownership/no-copy rules.

Bundles a parsed MAML source together with the column schema (cinfo) and table metadata (metadata) that parquet_parse_maml derives from it, so a single variable carries everything parquet_open_writer needs. %cinfo and %metadata are public: their fields (col(:), items(:)) and own type-bound procedures stay directly reachable, and the procedures below are flat convenience passthroughs (schema%set_column_available("id") instead of schema%cinfo%set_column_available("id")).

Which rows to pick out of a column: 1:, 1:10, 1:10:2 or an explicit list.

A read-time sort specification: an ordered list of sort KEYS, each naming one column and the direction to order it by. Passed as parquet_open_reader(..., sort_by=), or applied to an already-open reader with parquet_reader_set_sort. Every column read afterwards comes back in that order.

A lightweight, non-owning handle to one element of a parquet_string_column.

An owning, Arrow-LargeUtf8-compatible variable-length string column.

A whole table: a column store plus the row scope and provenance describing it. Declared by the caller (type(parquet_table) :: t), filled by parquet_open_table or parquet_new_table, and freed automatically when it goes out of scope.

A resolved handle on ONE column of a parquet_table: the slot, its kind and the table's row scope, captured once so a per-element loop stops resolving a name on every access.

Flat key-value table metadata: one array of parquet_metadata_entry plus the add_metadata family of type-bound procedures that append to it (one specific per supported type/kind, dispatched via the add_metadata generic).

One row of a table, as a lightweight handle: r = t%row(i).

Predefined-column table generated from the test schema.

A time of day, stored as nanoseconds since midnight, [0, 86400e9 - 1]. Holds any Parquet TIME unit (seconds/millis/micros/nanos) exactly. A default-initialized element is null.

An instant, stored losslessly as whole seconds since 1970-01-01T00:00:00 plus a normalized nanosecond-of-second part (always 0..999999999, also for pre-epoch instants). Holds any Parquet TIMESTAMP unit exactly over the full int64 range of the stored value. Timezone-agnostic: holds the stored epoch offset verbatim. A default-initialized element is null.

parquet_writer/parquet_reader own a handle to a C++-side Arrow/Parquet object with no automatic Fortran cleanup. Always prefer an explicit parquet_close_writer/parquet_close_reader call; the FINAL procedures below are only a safety net for a handle that's still open when its variable goes out of scope or is overwritten (e.g. an early RETURN between open and close), not a substitute for closing normally -- for a writer specifically, the safety net skips parquet_close_writer's completeness checks (so an incomplete write never crashes an implicit finalizer), meaning the resulting file is not guaranteed valid/complete unless parquet_close_writer was actually called.

A walk along one stream: the same values tier 0 addresses, reached in sequence.

A list of sort keys, applied in the order added -- the first key added is the primary one.

Successive sampling without replacement: draw one item with probability proportional to its weight, remove it, renormalise over the survivors, repeat.

One extracted sort key, in the canonical form the C++ engine takes.