parquet_table_test Derived Type

interface

private module function table_nrows(self) result(n)

Number of rows every column of this table holds.

Arguments

Return Value integer(kind=int64)

row count.

interface

private module function table_ncols(self, resident_only) result(n)

Number of columns this table has, or only the resident ones with resident_only.

Arguments

Return Value integer

column count.

interface

private module subroutine table_column_names(self, names, resident_only)

Copies out every column's name, in file/insertion order, blank-padded to the longest.

resident_only=.true. reports only the columns that have been read, in the same order, which is how a caller finds out what a lazy table is actually holding.

Arguments

interface

private module function table_column_index(self, name, found) result(j)

A column's 1-based position among the table's columns, or 0 when there is no such column. The inverse of %column_name, and the cheap way to hoist a lookup out of a loop that then queries the same column by position.

Arguments

Return Value integer

1-based position, or 0 on a reported miss.

interface

private module subroutine table_column_name(self, j, nm, found)

Copies out the name of the column at 1-based position j. The inverse of %column_index, and what makes a do j = 1, t%ncols() sweep able to report itself.

Arguments

private interface column_by_name()

Arguments

private interface column_by_index()

Arguments

private interface table_has_nulls()

Arguments

private interface table_has_nulls_at()

Arguments

private interface table_get_valid_mask()

Arguments

private interface table_get_valid_mask_elem()

Arguments

interface

private module function table_generation(self) result(g)

A counter bumped by every structural change to this table, for a caller holding a pointer across a call that might have invalidated it.

A stale %col pointer cannot be detected by Fortran, and this library cannot detect it either. What it can do is tell you whether anything structural happened: take the generation before, compare it after, and re-fetch the pointer if it moved. The counter is deliberately conservative -- every column- and row-structural entry point bumps it, whether or not that particular call actually relocated anything -- because a missed bump would give false confidence, while a spare one only costs a re-fetch. A call that changes nothing at all (see the no-detach rule) does not bump it.

Arguments

Return Value integer(kind=int64)

current generation.

interface

private module function table_has_column(self, name) result(found)

Whether a column of this name exists (supported or not).

Arguments

Return Value logical

.true. if the table has it.

private interface missing_columns_string()

Arguments

private interface missing_columns_array()

Arguments

private interface require_columns_string()

Arguments

private interface require_columns_array()

Arguments

private interface table_column_kind()

Arguments

private interface table_column_kind_at()

Arguments

private interface table_column_width()

Arguments

private interface table_column_width_at()

Arguments

private interface table_column_unit()

Arguments

private interface table_column_unit_at()

Arguments

private interface table_column_residency()

Arguments

private interface table_column_residency_at()

Arguments

private interface table_is_null_i32()

Arguments

private interface table_is_null_i64()

Arguments

private interface table_is_null_e32()

Arguments

private interface table_is_null_e64()

Arguments

private interface table_is_null_at_i32()

Arguments

private interface table_is_null_at_i64()

Arguments

private interface table_is_null_at_e32()

Arguments

private interface table_is_null_at_e64()

Arguments

interface

private module function table_is_detached(self) result(d)

Whether the table has been detached from its file by a row-structural mutation.

Arguments

Return Value logical

.true. once detached.

private interface table_is_supported()

Arguments

private interface table_is_supported_at()

Arguments

interface

private module subroutine table_filename(self, fname)

Copies out the file this table was opened from ("" for an in-memory table).

Arguments

interface

private module subroutine table_get_file_metadata(self, key, value, found)

Reads one key from the source file's table metadata. found reports a missing key.

Arguments

private interface prefetch_string()

Arguments

private interface prefetch_array()

Arguments

private interface prefetch_string()

Arguments

private interface prefetch_array()

Arguments

interface

private module subroutine table_materialize_every(self)

Reads every supported, file-backed column that is not resident yet -- the one-call way to make a whole table safe to use from a parallel region.

Arguments

interface

private module subroutine table_reload(self, name, force, found)

Re-reads one column from the file, discarding whatever is in the store -- the escape hatch back to the file's own values after %set has changed them locally. Only valid for a file-backed column of a table that has not been detached.

Discarding local edits is what this is FOR, so it says so rather than assuming: a column holding values the caller wrote (%user_populated) is refused unless force=.true. is passed, which puts %reload and %evict_column under one rule instead of two. A forced reload clears the mark, since the slot then holds the file's values again.

Arguments

interface

private module subroutine table_evict_column(self, name, force, found)

Releases one column's VALUES while keeping its slot -- the honest counterpart of %prefetch, and the way to give a column's memory back without losing the column.

The difference from %drop_column is what survives: an evicted column still appears in %column_names, still answers %kind/%width/%unit, and is READ AGAIN on the next touch. A dropped one is gone. So %drop_column is for a column you are finished with, and %evict_column for one you are finished with FOR NOW.

Only a file-backed column of an attached table can be evicted, and that restriction is the whole safety story: everywhere else the values are the only copy that exists, so evicting them would be silent data loss rather than a memory saving. A column built with %add_column, and any column of a detached table, is therefore an error naming what is wrong. Evicting a column that is not resident is a no-op.

Eviction is user-driven only. Nothing in this library evicts on its own -- no LRU, no memory budget -- so what a table holds stays predictable from the calls you wrote.

A column holding values the CALLER wrote (%user_populated) is refused as well, because the file's own values would come back on the next read and the edits would be gone with nothing to notice -- pass force=.true. to discard them on purpose. Note the protection covers what the value-setting API wrote, NOT a write made through a %col/%ref pointer: the library cannot tell such a write from a read, so a caller who edits that way marks the column with %set_user_populated themselves.

Arguments

interface

private module subroutine table_set_user_populated(self, name, flag, found)

Marks a column as holding values the CALLER wrote, or clears that mark.

The library sets this itself for every value-setting call (%set, %set_element, %set_slice, a row or column handle's %set, %set_null, %add_column, ...), and %evict_column and %reload then refuse that column unless force=.true. is passed. It cannot set it for a write made through the pointer %col/%ref hands out, because it cannot tell such a write from a read -- so a caller who edits a column that way marks it here, and gets the same protection. Clearing it says the opposite: the slot's values are the file's again, and may be discarded without force=.

Marking a column that holds no values is refused: there is nothing to protect, and the mark would outlive the read that filled the slot. Clearing is always allowed.

Arguments

interface

private module function table_is_user_populated(self, name, found) result(ok)

Whether a column is marked as holding values the caller wrote rather than the file's.

Reads no values and never triggers a read. A column that has not been read is never marked, so this answers .false. for one -- see %set_user_populated for what sets it.

Arguments

Return Value logical

.true. when the slot holds the caller's own writes.

interface

private module subroutine table_validate_qc(self)

Checks this table's read-time qc against the file, WITHOUT leaving the columns resident.

qc is enforced when a column is read, so on a lazy table a declared bound is only checked once something asks for that column -- which means a program that reads two of forty columns never finds out whether the other thirty-eight satisfy their bounds. This reads exactly the columns that declare a bound, letting the reader check them, and then releases the ones it had to read.

What it leaves behind is the point. Residency is recorded BEFORE anything is read, and only the columns this call made resident are released afterwards -- a column that was already in memory stays there, values and all. So it can be called at any time without disturbing what the program is working on.

A violation is reported the way it would be on an ordinary read: an abort, or a warning under qc_soft=. A table with no qc declared at all, and one built in memory, are no-ops -- there is nothing to check and no file to check it against.

Arguments

interface

private module subroutine table_print_stat(self, all)

Prints what this table holds, to standard output: one header line and one line per column, with each column's kind, width, row count, null count and min/max.

Materialized columns only, by default -- the header says how many of the table's columns those are, so a lazy table reports what it is actually holding rather than what its file contains. all=.true. lists every column, with - where a column that has not been read has nothing to report.

Printing never reads anything. A deferred plain-LIST column, whose width is only knowable from its data, prints as pending rather than being resolved -- a diagnostic that changes what it is diagnosing is worse than one that admits it does not know.

These are statistics of the values IN MEMORY, computed here by a plain Fortran scan. They are not the file's own footer statistics, and they are the only ones available for a column built with %add_column, which has no footer at all. The scan is O(rows) per column, so this is not a call to put in a loop over a large table.

Arguments

interface

private module function table_nrows_unfiltered(self) result(n)

Rows this table covers BEFORE filter=/sample_fraction= removed any -- the slice's own length in the slice regime, and the file's row count for a whole-file table.

%nrows() is what the table holds; this is what it was cut from, which nothing else can report once a transform is active: a filtered reader answers in survivors, so asking it afterwards gives the same number %nrows() already gave. Captured when the table opens, so it keeps answering after a row mutation has detached the table.

Equal to %nrows() when no filter or sample is in play. 0 for a table built in memory, which was not cut from anything.

Arguments

Return Value integer(kind=int64)

rows before the transform.

interface

private module function table_row_group_extent(self) result(n)

Rows in the row groups this table covers, which is what reading it actually costs.

A slice is read by row group, so a slice of 10 rows straddling two 100k-row groups decodes 200k rows to produce them. This reports that number, so a caller choosing slice boundaries can see when a slice is not paying for itself.

Equal to %nrows_unfiltered() when the slice lines up with row-group boundaries, and for a whole-file table always. 0 for a table built in memory.

Arguments

Return Value integer(kind=int64)

rows in the covering row groups.

interface

private module subroutine table_row_group_bounds(self, bounds, physical)

The same row ranges for an already-open table, without reopening the file, in THIS TABLE's own row numbering -- or, with physical=.true., in the file's.

The two differ only when the table does not hold every row of the file: a slice, a filter, a sample. Then bounds(1, rg)/bounds(2, rg) are the rows OF THIS TABLE that came from row group rg, which is what relates a row index in hand to the row group it was read from; physical=.true. answers in the file's numbering instead, which is what parquet_table_row_group_bounds and every slice bound are expressed in, and so is what to use for planning the next slice.

Both forms have ONE ENTRY PER PHYSICAL ROW GROUP and are index-aligned, so the two can be read side by side ("row group 7 holds file rows A..B, which are my rows C..D"). A row group contributing no rows to this table -- outside the slice, or filtered away entirely -- is reported as an EMPTY range, bounds(1, rg) > bounds(2, rg), rather than dropped; dropping it would break the alignment that makes the pairing possible.

Arguments

private interface row_at_i32()

Arguments

private interface row_at_i64()

Arguments

private interface get_slice_i32()

Arguments

private interface get_slice_i64()

Arguments

private interface get_slice_f32()

Arguments

private interface get_slice_f64()

Arguments

private interface get_slice_bool()

Arguments

private interface get_slice_date()

Arguments

private interface get_slice_time()

Arguments

private interface get_slice_ts()

Arguments

private interface get_slice_i32v()

Arguments

private interface get_slice_i64v()

Arguments

private interface get_slice_f32v()

Arguments

private interface get_slice_f64v()

Arguments

private interface get_slice_boolv()

Arguments

private interface get_slice_datev()

Arguments

private interface get_slice_timev()

Arguments

private interface get_slice_tsv()

Arguments

private interface get_slice_str()

Arguments

private interface get_slice_chr()

Arguments

private interface get_slice_chrv()

Arguments

private interface set_slice_i32()

Arguments

private interface set_slice_i64()

Arguments

private interface set_slice_f32()

Arguments

private interface set_slice_f64()

Arguments

private interface set_slice_bool()

Arguments

private interface set_slice_date()

Arguments

private interface set_slice_time()

Arguments

private interface set_slice_ts()

Arguments

private interface set_slice_i32v()

Arguments

private interface set_slice_i64v()

Arguments

private interface set_slice_f32v()

Arguments

private interface set_slice_f64v()

Arguments

private interface set_slice_boolv()

Arguments

private interface set_slice_datev()

Arguments

private interface set_slice_timev()

Arguments

private interface set_slice_tsv()

Arguments

private interface set_slice_chr()

Arguments

private interface set_slice_chrv()

Arguments

private interface col_ptr_i32()

Arguments

private interface col_ptr_i64()

Arguments

private interface col_ptr_f32()

Arguments

private interface col_ptr_f64()

Arguments

private interface col_ptr_bool()

Arguments

private interface col_ptr_date()

Arguments

private interface col_ptr_time()

Arguments

private interface col_ptr_ts()

Arguments

private interface col_ptr_i32v()

Arguments

private interface col_ptr_i64v()

Arguments

private interface col_ptr_f32v()

Arguments

private interface col_ptr_f64v()

Arguments

private interface col_ptr_boolv()

Arguments

private interface col_ptr_datev()

Arguments

private interface col_ptr_timev()

Arguments

private interface col_ptr_tsv()

Arguments

private interface col_ptr_strcol()

Arguments

private interface get_arr_i32()

Arguments

private interface get_arr_i64()

Arguments

private interface get_arr_f32()

Arguments

private interface get_arr_f64()

Arguments

private interface get_arr_bool()

Arguments

private interface get_arr_date()

Arguments

private interface get_arr_time()

Arguments

private interface get_arr_ts()

Arguments

private interface get_arr_i32v()

Arguments

private interface get_arr_i64v()

Arguments

private interface get_arr_f32v()

Arguments

private interface get_arr_f64v()

Arguments

private interface get_arr_boolv()

Arguments

private interface get_arr_datev()

Arguments

private interface get_arr_timev()

Arguments

private interface get_arr_tsv()

Arguments

private interface get_arr_str()

Arguments

private interface get_arr_chr()

Arguments

private interface get_arr_chrv()

Arguments

private interface set_arr_i32()

Arguments

private interface set_arr_i64()

Arguments

private interface set_arr_f32()

Arguments

private interface set_arr_f64()

Arguments

private interface set_arr_bool()

Arguments

private interface set_arr_date()

Arguments

private interface set_arr_time()

Arguments

private interface set_arr_ts()

Arguments

private interface set_arr_i32v()

Arguments

private interface set_arr_i64v()

Arguments

private interface set_arr_f32v()

Arguments

private interface set_arr_f64v()

Arguments

private interface set_arr_boolv()

Arguments

private interface set_arr_datev()

Arguments

private interface set_arr_timev()

Arguments

private interface set_arr_tsv()

Arguments

private interface set_arr_chr()

Arguments

private interface set_arr_chrv()

Arguments

private interface set_arr_strcol()

Arguments

private interface add_column_i32()

Arguments

private interface add_column_i64()

Arguments

private interface add_column_f32()

Arguments

private interface add_column_f64()

Arguments

private interface add_column_bool()

Arguments

private interface add_column_date()

Arguments

private interface add_column_time()

Arguments

private interface add_column_ts()

Arguments

private interface add_column_i32v()

Arguments

private interface add_column_i64v()

Arguments

private interface add_column_f32v()

Arguments

private interface add_column_f64v()

Arguments

private interface add_column_boolv()

Arguments

private interface add_column_datev()

Arguments

private interface add_column_timev()

Arguments

private interface add_column_tsv()

Arguments

private interface add_column_chr()

Arguments

private interface add_column_chrv()

Arguments

private interface add_column_strcol()

Arguments

private interface add_column_col()

Arguments

private interface get_element_i32_i32()

Arguments

private interface get_element_i32_i64()

Arguments

private interface get_element_i64_i32()

Arguments

private interface get_element_i64_i64()

Arguments

private interface get_element_f32_i32()

Arguments

private interface get_element_f32_i64()

Arguments

private interface get_element_f64_i32()

Arguments

private interface get_element_f64_i64()

Arguments

private interface get_element_bool_i32()

Arguments

private interface get_element_bool_i64()

Arguments

private interface get_element_date_i32()

Arguments

private interface get_element_date_i64()

Arguments

private interface get_element_time_i32()

Arguments

private interface get_element_time_i64()

Arguments

private interface get_element_ts_i32()

Arguments

private interface get_element_ts_i64()

Arguments

private interface get_element_i32v_i32()

Arguments

private interface get_element_i32v_i64()

Arguments

private interface get_element_i64v_i32()

Arguments

private interface get_element_i64v_i64()

Arguments

private interface get_element_f32v_i32()

Arguments

private interface get_element_f32v_i64()

Arguments

private interface get_element_f64v_i32()

Arguments

private interface get_element_f64v_i64()

Arguments

private interface get_element_boolv_i32()

Arguments

private interface get_element_boolv_i64()

Arguments

private interface get_element_datev_i32()

Arguments

private interface get_element_datev_i64()

Arguments

private interface get_element_timev_i32()

Arguments

private interface get_element_timev_i64()

Arguments

private interface get_element_tsv_i32()

Arguments

private interface get_element_tsv_i64()

Arguments

private interface get_element_chr_i32()

Arguments

private interface get_element_chr_i64()

Arguments

private interface get_element_chrv_i32()

Arguments

private interface get_element_chrv_i64()

Arguments

private interface set_element_i32_i32()

Arguments

private interface set_element_i32_i64()

Arguments

private interface set_element_i64_i32()

Arguments

private interface set_element_i64_i64()

Arguments

private interface set_element_f32_i32()

Arguments

private interface set_element_f32_i64()

Arguments

private interface set_element_f64_i32()

Arguments

private interface set_element_f64_i64()

Arguments

private interface set_element_bool_i32()

Arguments

private interface set_element_bool_i64()

Arguments

private interface set_element_date_i32()

Arguments

private interface set_element_date_i64()

Arguments

private interface set_element_time_i32()

Arguments

private interface set_element_time_i64()

Arguments

private interface set_element_ts_i32()

Arguments

private interface set_element_ts_i64()

Arguments

private interface set_element_i32v_i32()

Arguments

private interface set_element_i32v_i64()

Arguments

private interface set_element_i64v_i32()

Arguments

private interface set_element_i64v_i64()

Arguments

private interface set_element_f32v_i32()

Arguments

private interface set_element_f32v_i64()

Arguments

private interface set_element_f64v_i32()

Arguments

private interface set_element_f64v_i64()

Arguments

private interface set_element_boolv_i32()

Arguments

private interface set_element_boolv_i64()

Arguments

private interface set_element_datev_i32()

Arguments

private interface set_element_datev_i64()

Arguments

private interface set_element_timev_i32()

Arguments

private interface set_element_timev_i64()

Arguments

private interface set_element_tsv_i32()

Arguments

private interface set_element_tsv_i64()

Arguments

private interface set_element_chr_i32()

Arguments

private interface set_element_chr_i64()

Arguments

private interface set_element_chrv_i32()

Arguments

private interface set_element_chrv_i64()

Arguments

private interface set_null_i32()

Arguments

private interface set_null_i64()

Arguments

private interface set_null_e32()

Arguments

private interface set_null_e64()

Arguments

private interface set_null_mask()

Arguments

private interface set_null_mask_elem()

Arguments

private interface clear_null_i32()

Arguments

private interface clear_null_i64()

Arguments

private interface clear_null_e32()

Arguments

private interface clear_null_e64()

Arguments

interface

private module subroutine table_compact_validity(self, name, found)

Drops a column's null bitmap when it no longer holds any null, so a column that HAD nulls and no longer does stops paying for the bitmap. Scans the column, so it is not free -- a whole-column %set already compacts on its own and does not need this. Idempotent: calling it on an already-compact column is a cheap no-op.

Arguments

interface

private module subroutine table_ensure_validity(self, name, found)

Materializes a column's validity storage up front, so concurrent nulling allocates nothing. See table_check_shared_write.

Arguments

interface

private module subroutine table_drop_column(self, name, force, found)

Removes a column from the table. Cheap, and it does NOT detach: dropping a column leaves every remaining column the same length, so the table can still read the ones it has not read yet. Dropping a column that was never read is the memory-reclaiming case and reads nothing.

Arguments

interface

private module subroutine table_rename_column(self, old_name, new_name, found)

Changes a column's name. Only the name a caller looks it up by changes -- a file-backed column that has not been read yet still reads from the same physical column afterwards. A predefined column cannot be renamed at all (its accessor is bound to the name at compile time), and there is no force= for it.

Arguments

interface

private module subroutine table_copy_column(self, name, new_name, to_kind, exact, found)

Adds a NEW column holding a copy of name's values, leaving the source column untouched. With to_kind absent it is a plain deep copy and works for EVERY kind the library can read -- string, temporal, logical and the vector kinds included. With to_kind given it copies and converts, and the conversion rules are %cast's.

exact defaults to .true. here, the opposite of %cast: a copy is usually taken to keep something, so a value that would not survive the round trip is an error naming the row and the value rather than a silent truncation. Every value is checked before anything is written, so a rejected copy leaves the table exactly as it was. The unit carries over unchanged -- a kind conversion is not a unit change.

Arguments

interface

private module subroutine table_cast(self, name, to_kind, exact, found)

Converts a column to to_kind IN PLACE, so that %col can be called with a kind the calling code has decided on rather than the one the file happens to hold. A column already of to_kind is left alone.

The conversions allowed are exactly those the reader and writer already perform between numeric kinds: int32 <-> int64, float32 <-> float64, and either integer kind to or from either real kind, scalar or vector, never changing a column's width. An integer overflow, and a real value with a fractional part converted to an integer kind, are errors naming the row and the value. Anything else -- logical, string, temporal, or a conversion that would change a column's rank -- is refused outright.

exact defaults to .false.: precision loss (real64 to real32, or a large integer to a real kind) is silent, exactly as it is on the read path. Pass .true. to make any value that would not survive the round trip an error instead.

This invalidates any pointer previously taken from %col for this column, which Fortran cannot detect -- take the pointer again afterwards.

Arguments

interface

private module subroutine table_filter_rows(self, keep)

Keeps only the rows whose keep entry is .true., dropping the rest from EVERY column.

Row-structural, so it DETACHES the table from its file: after it, a column that was never read can never be read, because the file's rows no longer line up with the rows in memory. Materialize what you need first (%prefetch/%materialize_all). An all-.true. mask removes no row, so it changes nothing and does not detach.

Arguments

private interface table_sort_by()

Arguments

private interface table_sort_by_string()

Arguments

private interface table_top_n()

Arguments

private interface table_top_n_string()

Arguments

private interface table_argsort_by_i32()

Arguments

private interface table_argsort_by_i64()

Arguments

private interface table_argsort_by_string_i32()

Arguments

private interface table_argsort_by_string_i64()

Arguments

private interface table_argsort_partial_i32()

Arguments

private interface table_argsort_partial_i64()

Arguments

private interface table_argsort_partial_string_i32()

Arguments

private interface table_argsort_partial_string_i64()

Arguments

private interface table_is_sorted_by()

Arguments

private interface table_is_sorted_by_string()

Arguments

private interface table_delete_rows_i32()

Arguments

private interface table_delete_rows_i64()

Arguments

private interface table_truncate_i32()

Arguments

private interface table_truncate_i64()

Arguments

private interface table_append_table()

Arguments

private interface table_append_row()

Arguments

private interface table_append_null_rows_i32()

Arguments

private interface table_append_null_rows_i64()

Arguments

interface

private module subroutine table_compact(self)

Releases the spare storage capacity that appending left behind, so every resident column occupies exactly the rows it holds.

A no-op on a table that has not been appended to. Capacity only ever comes from an append: reading a column from a file allocates exact-fit, and so does every rebuild (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate), which hand their memory back on their own. So this is safe to call unconditionally -- before parquet_write_table, say -- and costs nothing when there is nothing to release. It is not NEEDED before a write: the writer reads through a pointer that is already bounded by the row count, so slack costs a write nothing.

It INVALIDATES every pointer obtained from %col and every row handle, because it reallocates storage. That makes it the one procedure in parquet_tables_mutate that does so -- everything else there leaves the row set and the storage alone. It does NOT detach: the row set is unchanged, so the table keeps its file and a column not yet read can still be read afterwards.

%generation() advances only if something was actually released, which is what makes the no-op above observable: a caller following the documented take-generation/compare/re-fetch pattern re-fetches only when a pointer really did die.

Refused on a shared table, like every other mutation except %append.

Arguments

private interface table_reserve_i32()

Arguments

private interface table_reserve_i64()

Arguments

interface

private module subroutine table_reserve_columns(self, n)

Makes room for n COLUMNS, and in doing so gives %add_column a guarantee it does not otherwise have:

While spare column capacity remains, adding a column under a NEW name relocates no existing column's storage, moves no existing column's slot position, and does not advance %generation(). A pointer taken from %col, a parquet_table_col handle and a parquet_table_row handle all stay valid across such a call. A reservation survives %clone and %clone_structure, so a copy starts with the same spare capacity. Replacing an existing column (force=.true.) is not covered -- it frees that column's storage -- and neither is any row-structural mutation.

That is what makes the commonest derived-column idiom safe rather than merely lucky. Without a reservation, an %add_column that happens to fill the slot array reallocates it, and Fortran leaves a pointer's association status UNDEFINED across the MOVE_ALLOC that does it -- code that usually works and is not permitted to:

 call t%reserve_columns(t%ncols() + 2)   ! two derived columns coming
 call t%col("mag_g", g)                  ! pointers taken up front...
 call t%col("mag_r", r)
 call t%add_column("g_minus_r", g - r)   ! ...and still valid here, by contract

Reserve first, take pointers second -- the same rule %reserve (rows) follows. Growing the capacity is itself a relocation, so this call invalidates every outstanding pointer and advances %generation() when it actually grows; below the current capacity it is a no-op, exactly as %reserve below the current row count is.

n is the TOTAL capacity to make room for, not an increment. Deliberately a plain default integer and not also an int64 form: a column count cannot exceed int32 -- Arrow's own Schema::num_fields() is an int32_t and the writer already guards that ceiling -- so the dual-kind rule in CLAUDE.md does not apply. Refused on a shared table, like every other structural change; does not detach.

Arguments

interface

private module function table_column_capacity(self, free) result(n)

How many column slots are allocated (%ncols() of them in use), or -- with free=.true. -- how many are spare.

This is what %reserve_columns acts on, and the two are inverses: after call t%reserve_columns(n) with n above the current capacity, %column_capacity() is n. Capacity only ever grows: %compact releases row storage rather than slots, and %drop_column keeps the slot it vacated.

A metadata query -- it reads no column data.

Arguments

Return Value integer

slots allocated, or spare.

interface

private module subroutine table_clone(self, out)

Makes out an independent deep copy of this table -- the way to keep a version to go back to, since mutation is in place and there is no undo.

Columns already read are copied; columns not yet read stay unread, so a clone costs what the table actually holds rather than what its file contains. A live file-backed table's clone opens its OWN reader on the same file and stays lazy; a detached or in-memory table's clone has no reader, like its source.

out must be declared as the same concrete type as self.

Arguments

interface

private module subroutine table_clone_structure(self, out, resident_only)

Makes out an EMPTY table with this table's columns: same names, kinds, widths and units, zero rows, no file behind it.

This is the first half of the bulk-append idiom -- %clone_structure a batch, fill it with %add_column/%set, then %append it -- which is how a program adds many rows without appending one at a time. A batch made this way structurally cannot have the wrong column set, and abandoning a half-filled one is just a variable going out of scope. Columns whose type this library cannot read are left out.

resident_only=.true. copies only the columns that have been read, which is also the way to clone the structure of a table whose other columns are still deferred.

Arguments

interface

private module subroutine table_bind_predefined(self, names, kinds, widths, from_file, context, exact, units)

Binds the predefined columns a GENERATED table type declares: checks each one, converts it to the kind the schema declared, reads it, and marks the slot predefined.

This is the one library call a generated type's %init makes (doc/pages/utilities/generated-tables.md); it is public only because a generated module is a DIFFERENT module and parquet_table's components are private, so there is no other way in. Hand-written code rarely needs it -- a table opened with parquet_open_table already reaches every column by name.

Per column, in names order:

• a from_file column must exist (after any remap:), or this aborts naming it;
• its width must equal the declared widths entry, or this aborts;
• if its kind differs from the declared one, %cast converts it -- and a conversion that can lose information (a narrowing, or an integer wider than the target real's mantissa) emits a warning naming the table and column, since the declaration is a contract the file does not have to honour exactly;
• every from_file column is then read in ONE %prefetch, after the casts, so a converted column decodes straight into its declared kind rather than being read twice;
• a column with from_file .false. -- a source: computed field, or any column of a from-scratch table -- is created with %nrows() all-null rows instead of being looked for in the file.

Passing from_file all .false. is exactly what an in-memory generated table does, so the same procedure serves a file-backed and a from-scratch construction.

units FILLS IN a unit the column does not already have; it never overwrites one. A read-in MAML describes the physical file and is authoritative about what a file column holds, so a declaration must not override it -- but a computed column has no other source of a unit at all, and a file opened without a MAML has none either, which is where the declared one belongs.

Arguments

private interface table_assign_guard()

Arguments

private subroutine parquet_table_test_init(self, filename, maml, filter, sort, qc, qc_soft, use_threads, sample_fraction, sample_seed, exact)

Opens the file and binds every predefined column this schema declares: each is checked for presence, kind and width, converted to its declared kind where a conversion rule applies, and fully materialized before this returns. Every optional argument is forwarded to parquet_open_table unchanged, except exact, which belongs to the kind conversion.

Arguments

private subroutine parquet_table_test_init_slice_i32(self, filename, row_lo, row_hi, maml, filter, qc, qc_soft, use_threads, sample_fraction, sample_seed, exact)

%init_slice specific taking i32 row bounds; see the generic binding.

Arguments

private subroutine parquet_table_test_init_slice_i64(self, filename, row_lo, row_hi, maml, filter, qc, qc_soft, use_threads, sample_fraction, sample_seed, exact)

%init_slice specific taking i64 row bounds; see the generic binding.

Arguments

private subroutine parquet_table_test_init_empty_none(self)

%init_empty specific taking no row count: every predefined column is created with zero rows, to be grown with %append.

Arguments

private subroutine parquet_table_test_init_empty_i32(self, nrows)

%init_empty specific taking an i32 row count: every predefined column is created with nrows all-null rows, ready to be filled in place.

Arguments

private subroutine parquet_table_test_init_empty_i64(self, nrows)

%init_empty specific taking an i64 row count: every predefined column is created with nrows all-null rows, ready to be filled in place.

Arguments

private subroutine parquet_table_test_init_extra(self)

Resets and initializes this type's own components. Called by every constructor, so whatever you write here happens exactly once however the table was built -- and so your own parameters must be set AFTER %init returns, not before.

Arguments

private subroutine parquet_table_test_clone_extra(self, out, structure_only)

Copies this type's own components when the table is cloned. out is guaranteed to have the same dynamic type as self. structure_only is .true. when called from %clone_structure, i.e. when out has the same columns but no rows.

Arguments

private function parquet_table_test_uberid_all(self) result(p)

Object ID field. (int64) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int64), pointer, (:)

alias to the column's storage.

private function parquet_table_test_uberid_at_i32(self, i) result(p)

Object ID field. (int64) Row i alone. Repeats the column lookup on every call -- take %uberid() once instead when iterating.

Arguments

Return Value integer(kind=int64), pointer

alias to that row's storage.

private function parquet_table_test_uberid_at_i64(self, i) result(p)

Object ID field. (int64) Row i alone. Repeats the column lookup on every call -- take %uberid() once instead when iterating.

Arguments

Return Value integer(kind=int64), pointer

alias to that row's storage.

private function parquet_table_test_uberid_rng_i32(self, lo, hi) result(p)

Object ID field. (int64) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_uberid_rng_i64(self, lo, hi) result(p)

Object ID field. (int64) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_idx_all(self) result(p)

A plain int32 scalar column. (int32) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int32), pointer, (:)

alias to the column's storage.

private function parquet_table_test_idx_at_i32(self, i) result(p)

A plain int32 scalar column. (int32) Row i alone. Repeats the column lookup on every call -- take %idx() once instead when iterating.

Arguments

Return Value integer(kind=int32), pointer

alias to that row's storage.

private function parquet_table_test_idx_at_i64(self, i) result(p)

A plain int32 scalar column. (int32) Row i alone. Repeats the column lookup on every call -- take %idx() once instead when iterating.

Arguments

Return Value integer(kind=int32), pointer

alias to that row's storage.

private function parquet_table_test_idx_rng_i32(self, lo, hi) result(p)

A plain int32 scalar column. (int32) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int32), pointer, (:)

alias to that range's storage.

private function parquet_table_test_idx_rng_i64(self, lo, hi) result(p)

A plain int32 scalar column. (int32) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int32), pointer, (:)

alias to that range's storage.

private function parquet_table_test_flag_all(self) result(p)

A boolean scalar column. (boolean) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value logical, pointer, (:)

alias to the column's storage.

private function parquet_table_test_flag_at_i32(self, i) result(p)

A boolean scalar column. (boolean) Row i alone. Repeats the column lookup on every call -- take %flag() once instead when iterating.

Arguments

Return Value logical, pointer

alias to that row's storage.

private function parquet_table_test_flag_at_i64(self, i) result(p)

A boolean scalar column. (boolean) Row i alone. Repeats the column lookup on every call -- take %flag() once instead when iterating.

Arguments

Return Value logical, pointer

alias to that row's storage.

private function parquet_table_test_flag_rng_i32(self, lo, hi) result(p)

A boolean scalar column. (boolean) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value logical, pointer, (:)

alias to that range's storage.

private function parquet_table_test_flag_rng_i64(self, lo, hi) result(p)

A boolean scalar column. (boolean) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value logical, pointer, (:)

alias to that range's storage.

private function parquet_table_test_name_all(self) result(p)

Name of the object. (string) The packed string store itself, not a character array -- read it and edit its values in place, but do not change its length or element count through it.

Arguments

Return Value type(parquet_string_column), pointer

alias to the packed store.

private function parquet_table_test_name_at_i32(self, i) result(h)

Name of the object. (string) A zero-copy handle to row i. Repeats the column lookup on every call.

Arguments

Return Value type(parquet_string)

handle to that row's value.

private function parquet_table_test_name_at_i64(self, i) result(h)

Name of the object. (string) A zero-copy handle to row i. Repeats the column lookup on every call.

Arguments

Return Value type(parquet_string)

handle to that row's value.

private function parquet_table_test_name_rng_i32(self, lo, hi) result(h)

Name of the object. (string) One zero-copy handle per row of [lo, hi], in order.

Arguments

Return Value type(parquet_string), allocatable, (:)

one handle per row.

private function parquet_table_test_name_rng_i64(self, lo, hi) result(h)

Name of the object. (string) One zero-copy handle per row of [lo, hi], in order.

Arguments

Return Value type(parquet_string), allocatable, (:)

one handle per row.

private subroutine parquet_table_test_name_chr(self, arr)

Name of the object. (string) Copied out as a character array sized to the longest value present. A null element comes back blank -- gate on %is_null to tell a null from a genuinely empty string.

Arguments

private function parquet_table_test_ra_all(self) result(p)

Right ascension. Unit: deg. (float64) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to the column's storage.

private function parquet_table_test_ra_at_i32(self, i) result(p)

Right ascension. Unit: deg. (float64) Row i alone. Repeats the column lookup on every call -- take %ra() once instead when iterating.

Arguments

Return Value real(kind=real64), pointer

alias to that row's storage.

private function parquet_table_test_ra_at_i64(self, i) result(p)

Right ascension. Unit: deg. (float64) Row i alone. Repeats the column lookup on every call -- take %ra() once instead when iterating.

Arguments

Return Value real(kind=real64), pointer

alias to that row's storage.

private function parquet_table_test_ra_rng_i32(self, lo, hi) result(p)

Right ascension. Unit: deg. (float64) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_ra_rng_i64(self, lo, hi) result(p)

Right ascension. Unit: deg. (float64) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_dec_all(self) result(p)

Declination. Unit: deg. (float64) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to the column's storage.

private function parquet_table_test_dec_at_i32(self, i) result(p)

Declination. Unit: deg. (float64) Row i alone. Repeats the column lookup on every call -- take %dec() once instead when iterating.

Arguments

Return Value real(kind=real64), pointer

alias to that row's storage.

private function parquet_table_test_dec_at_i64(self, i) result(p)

Declination. Unit: deg. (float64) Row i alone. Repeats the column lookup on every call -- take %dec() once instead when iterating.

Arguments

Return Value real(kind=real64), pointer

alias to that row's storage.

private function parquet_table_test_dec_rng_i32(self, lo, hi) result(p)

Declination. Unit: deg. (float64) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_dec_rng_i64(self, lo, hi) result(p)

Declination. Unit: deg. (float64) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_crd_all(self) result(p)

Comoving coordinates. Unit: Mpc. (float32, width 3) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real32), pointer, (:,:)

alias to the column's storage.

private function parquet_table_test_crd_at_i32(self, i) result(p)

Comoving coordinates. Unit: Mpc. (float32, width 3) Row i's 3 values. Repeats the column lookup on every call -- take %crd() once instead when iterating.

Arguments

Return Value real(kind=real32), pointer, (:)

alias to that row's storage.

private function parquet_table_test_crd_at_i64(self, i) result(p)

Comoving coordinates. Unit: Mpc. (float32, width 3) Row i's 3 values. Repeats the column lookup on every call -- take %crd() once instead when iterating.

Arguments

Return Value real(kind=real32), pointer, (:)

alias to that row's storage.

private function parquet_table_test_crd_rng_i32(self, lo, hi) result(p)

Comoving coordinates. Unit: Mpc. (float32, width 3) Rows lo through hi inclusive, full width. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real32), pointer, (:,:)

alias to that range's storage.

private function parquet_table_test_crd_rng_i64(self, lo, hi) result(p)

Comoving coordinates. Unit: Mpc. (float32, width 3) Rows lo through hi inclusive, full width. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real32), pointer, (:,:)

alias to that range's storage.

private function parquet_table_test_counts_all(self) result(p)

An int32 vector column. (int32, width 2) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int32), pointer, (:,:)

alias to the column's storage.

private function parquet_table_test_counts_at_i32(self, i) result(p)

An int32 vector column. (int32, width 2) Row i's 2 values. Repeats the column lookup on every call -- take %counts() once instead when iterating.

Arguments

Return Value integer(kind=int32), pointer, (:)

alias to that row's storage.

private function parquet_table_test_counts_at_i64(self, i) result(p)

An int32 vector column. (int32, width 2) Row i's 2 values. Repeats the column lookup on every call -- take %counts() once instead when iterating.

Arguments

Return Value integer(kind=int32), pointer, (:)

alias to that row's storage.

private function parquet_table_test_counts_rng_i32(self, lo, hi) result(p)

An int32 vector column. (int32, width 2) Rows lo through hi inclusive, full width. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int32), pointer, (:,:)

alias to that range's storage.

private function parquet_table_test_counts_rng_i64(self, lo, hi) result(p)

An int32 vector column. (int32, width 2) Rows lo through hi inclusive, full width. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value integer(kind=int32), pointer, (:,:)

alias to that range's storage.

private function parquet_table_test_passed_all(self) result(p)

A boolean vector column. (boolean, width 2) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value logical, pointer, (:,:)

alias to the column's storage.

private function parquet_table_test_passed_at_i32(self, i) result(p)

A boolean vector column. (boolean, width 2) Row i's 2 values. Repeats the column lookup on every call -- take %passed() once instead when iterating.

Arguments

Return Value logical, pointer, (:)

alias to that row's storage.

private function parquet_table_test_passed_at_i64(self, i) result(p)

A boolean vector column. (boolean, width 2) Row i's 2 values. Repeats the column lookup on every call -- take %passed() once instead when iterating.

Arguments

Return Value logical, pointer, (:)

alias to that row's storage.

private function parquet_table_test_passed_rng_i32(self, lo, hi) result(p)

A boolean vector column. (boolean, width 2) Rows lo through hi inclusive, full width. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value logical, pointer, (:,:)

alias to that range's storage.

private function parquet_table_test_passed_rng_i64(self, lo, hi) result(p)

A boolean vector column. (boolean, width 2) Rows lo through hi inclusive, full width. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value logical, pointer, (:,:)

alias to that range's storage.

private function parquet_table_test_obsdate_all(self) result(p)

A date column. (date) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_date), pointer, (:)

alias to the column's storage.

private function parquet_table_test_obsdate_at_i32(self, i) result(p)

A date column. (date) Row i alone. Repeats the column lookup on every call -- take %obsdate() once instead when iterating.

Arguments

Return Value type(parquet_date), pointer

alias to that row's storage.

private function parquet_table_test_obsdate_at_i64(self, i) result(p)

A date column. (date) Row i alone. Repeats the column lookup on every call -- take %obsdate() once instead when iterating.

Arguments

Return Value type(parquet_date), pointer

alias to that row's storage.

private function parquet_table_test_obsdate_rng_i32(self, lo, hi) result(p)

A date column. (date) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_date), pointer, (:)

alias to that range's storage.

private function parquet_table_test_obsdate_rng_i64(self, lo, hi) result(p)

A date column. (date) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_date), pointer, (:)

alias to that range's storage.

private function parquet_table_test_obstime_all(self) result(p)

A millisecond time column. (time) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_time), pointer, (:)

alias to the column's storage.

private function parquet_table_test_obstime_at_i32(self, i) result(p)

A millisecond time column. (time) Row i alone. Repeats the column lookup on every call -- take %obstime() once instead when iterating.

Arguments

Return Value type(parquet_time), pointer

alias to that row's storage.

private function parquet_table_test_obstime_at_i64(self, i) result(p)

A millisecond time column. (time) Row i alone. Repeats the column lookup on every call -- take %obstime() once instead when iterating.

Arguments

Return Value type(parquet_time), pointer

alias to that row's storage.

private function parquet_table_test_obstime_rng_i32(self, lo, hi) result(p)

A millisecond time column. (time) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_time), pointer, (:)

alias to that range's storage.

private function parquet_table_test_obstime_rng_i64(self, lo, hi) result(p)

A millisecond time column. (time) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_time), pointer, (:)

alias to that range's storage.

private function parquet_table_test_obsstamp_all(self) result(p)

A UTC microsecond timestamp column. (timestamp) The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_timestamp), pointer, (:)

alias to the column's storage.

private function parquet_table_test_obsstamp_at_i32(self, i) result(p)

A UTC microsecond timestamp column. (timestamp) Row i alone. Repeats the column lookup on every call -- take %obsstamp() once instead when iterating.

Arguments

Return Value type(parquet_timestamp), pointer

alias to that row's storage.

private function parquet_table_test_obsstamp_at_i64(self, i) result(p)

A UTC microsecond timestamp column. (timestamp) Row i alone. Repeats the column lookup on every call -- take %obsstamp() once instead when iterating.

Arguments

Return Value type(parquet_timestamp), pointer

alias to that row's storage.

private function parquet_table_test_obsstamp_rng_i32(self, lo, hi) result(p)

A UTC microsecond timestamp column. (timestamp) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_timestamp), pointer, (:)

alias to that range's storage.

private function parquet_table_test_obsstamp_rng_i64(self, lo, hi) result(p)

A UTC microsecond timestamp column. (timestamp) Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value type(parquet_timestamp), pointer, (:)

alias to that range's storage.

private subroutine parquet_table_test_tags_chr(self, arr)

A string vector column, which has only the character copy-out form. (string, width 2) Copied out as a character array sized to the longest value present. A null element comes back blank -- gate on %is_null to tell a null from a genuinely empty string.

Arguments

private function parquet_table_test_flux_all(self) result(p)

Filled in by the program, never read from the file. Unit: Jy. (float64) Computed: no file column is read for it. The whole column. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to the column's storage.

private function parquet_table_test_flux_at_i32(self, i) result(p)

Filled in by the program, never read from the file. Unit: Jy. (float64) Computed: no file column is read for it. Row i alone. Repeats the column lookup on every call -- take %flux() once instead when iterating.

Arguments

Return Value real(kind=real64), pointer

alias to that row's storage.

private function parquet_table_test_flux_at_i64(self, i) result(p)

Filled in by the program, never read from the file. Unit: Jy. (float64) Computed: no file column is read for it. Row i alone. Repeats the column lookup on every call -- take %flux() once instead when iterating.

Arguments

Return Value real(kind=real64), pointer

alias to that row's storage.

private function parquet_table_test_flux_rng_i32(self, lo, hi) result(p)

Filled in by the program, never read from the file. Unit: Jy. (float64) Computed: no file column is read for it. Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to that range's storage.

private function parquet_table_test_flux_rng_i64(self, lo, hi) result(p)

Filled in by the program, never read from the file. Unit: Jy. (float64) Computed: no file column is read for it. Rows lo through hi inclusive. Points into the live storage: zero copy, writable, and invalidated by any row-structural mutation (%filter_rows, %sort_by, %top_n, %delete_rows, %truncate, %append, %append_null_rows).

Arguments

Return Value real(kind=real64), pointer, (:)

alias to that range's storage.