!=========================================== ! Author: Elmo Tempel (elmo.tempel@ut.ee) !=========================================== ! ! GENERATED FILE -- DO NOT EDIT BY HAND. ! Regenerate with: tools/generate_parquet_sorting.py ! The type table lives in that script; edit it there, not here. ! !> `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. !! !! The six intrinsic types' `pf_argsort` specifics are one tier down, in !! `src/parquet_argsort_kernel.f90`. !! !! Both are thin: they extract the values into the engine's canonical key form, run the engine, and !! -- for `pf_sort` -- gather the result. No ordering decision is made here. !! !! **The int32 permutation forms exist because a caller with a default-kind `INTEGER` should not be !! forced to widen one** (CLAUDE.md's "Public numeric arguments"). They compute in int64 and narrow !! at the end, aborting rather than truncating when the array is longer than `huge(1_int32)`. submodule (parquet_sorting) parquet_sorting_argsort implicit none ! contains ! module procedure argsort_date_i32 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo integer(int64), allocatable :: perm64(:), go64(:) ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_date(values, buf, desc, nlo, "pf_argsort", threads=threads) if (present(group_offsets)) then call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm64, & threads=threads, group_offsets=go64) call narrow_offsets(go64, "pf_argsort", group_offsets) else call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm64, threads=threads) end if call narrow_perm(perm64, "pf_argsort", perm, threads=threads) end procedure argsort_date_i32 ! module procedure argsort_date_i64 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_date(values, buf, desc, nlo, "pf_argsort", threads=threads) call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm, threads=threads, & group_offsets=group_offsets) end procedure argsort_date_i64 ! module procedure argsort_time_i32 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo integer(int64), allocatable :: perm64(:), go64(:) ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_time(values, buf, desc, nlo, "pf_argsort", threads=threads) if (present(group_offsets)) then call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm64, & threads=threads, group_offsets=go64) call narrow_offsets(go64, "pf_argsort", group_offsets) else call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm64, threads=threads) end if call narrow_perm(perm64, "pf_argsort", perm, threads=threads) end procedure argsort_time_i32 ! module procedure argsort_time_i64 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_time(values, buf, desc, nlo, "pf_argsort", threads=threads) call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm, threads=threads, & group_offsets=group_offsets) end procedure argsort_time_i64 ! module procedure argsort_ts_i32 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo integer(int64), allocatable :: perm64(:), go64(:) ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_ts(values, buf, desc, nlo, "pf_argsort", threads=threads) if (present(group_offsets)) then call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm64, & threads=threads, group_offsets=go64) call narrow_offsets(go64, "pf_argsort", group_offsets) else call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm64, threads=threads) end if call narrow_perm(perm64, "pf_argsort", perm, threads=threads) end procedure argsort_ts_i32 ! module procedure argsort_ts_i64 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_ts(values, buf, desc, nlo, "pf_argsort", threads=threads) call drive_engine_grouped(buf, size(values, kind=int64), "pf_argsort", perm, threads=threads, & group_offsets=group_offsets) end procedure argsort_ts_i64 ! module procedure argsort_strcol_i32 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo integer(int64), allocatable :: perm64(:), go64(:) ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_strcol(values, buf, desc, nlo, "pf_argsort", threads=threads) if (present(group_offsets)) then call drive_engine_grouped(buf, values%size(), "pf_argsort", perm64, & threads=threads, group_offsets=go64) call narrow_offsets(go64, "pf_argsort", group_offsets) else call drive_engine_grouped(buf, values%size(), "pf_argsort", perm64, threads=threads) end if call narrow_perm(perm64, "pf_argsort", perm, threads=threads) end procedure argsort_strcol_i32 ! module procedure argsort_strcol_i64 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_strcol(values, buf, desc, nlo, "pf_argsort", threads=threads) call drive_engine_grouped(buf, values%size(), "pf_argsort", perm, threads=threads, & group_offsets=group_offsets) end procedure argsort_strcol_i64 ! module procedure argsort_col_i32 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo integer(int64), allocatable :: perm64(:), go64(:) ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_col(values, buf, desc, nlo, "pf_argsort", threads=threads) if (present(group_offsets)) then call drive_engine_grouped(buf, values%length(), "pf_argsort", perm64, & threads=threads, group_offsets=go64) call narrow_offsets(go64, "pf_argsort", group_offsets) else call drive_engine_grouped(buf, values%length(), "pf_argsort", perm64, threads=threads) end if call narrow_perm(perm64, "pf_argsort", perm, threads=threads) end procedure argsort_col_i32 ! module procedure argsort_col_i64 type(sort_key_buf), allocatable :: buf(:) logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first call extract_col(values, buf, desc, nlo, "pf_argsort", threads=threads) call drive_engine_grouped(buf, values%length(), "pf_argsort", perm, threads=threads, & group_offsets=group_offsets) end procedure argsort_col_i64 ! module procedure argsort_keys_i32 integer :: gek integer(int64), allocatable :: perm64(:), go64(:) ! if (keys%nkeys < 1) then error stop EP // "pf_argsort: this pf_sort_keys has no key; " // & "call keys%add(...) at least once before sorting" end if call resolve_group_nkeys(keys, group_nkeys, present(group_offsets), "pf_argsort", gek) if (present(group_offsets)) then call drive_engine_grouped(keys%keys(1:keys%nkeys), keys%nrows, "pf_argsort", & perm64, threads=threads, group_offsets=go64, group_ekeys=gek) call narrow_offsets(go64, "pf_argsort", group_offsets) else call drive_engine_grouped(keys%keys(1:keys%nkeys), keys%nrows, "pf_argsort", & perm64, threads=threads) end if call narrow_perm(perm64, "pf_argsort", perm, threads=threads) end procedure argsort_keys_i32 ! module procedure argsort_keys_i64 integer :: gek ! if (keys%nkeys < 1) then error stop EP // "pf_argsort: this pf_sort_keys has no key; " // & "call keys%add(...) at least once before sorting" end if call resolve_group_nkeys(keys, group_nkeys, present(group_offsets), "pf_argsort", gek) call drive_engine_grouped(keys%keys(1:keys%nkeys), keys%nrows, "pf_argsort", perm, & threads=threads, group_offsets=group_offsets, group_ekeys=gek) end procedure argsort_keys_i64 ! module procedure sort_i32 type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_i32(values, buf, desc, nlo, "pf_sort", is_valid=is_valid, threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do ! Deliberately ALLOCATED even when `is_valid` was absent. The module's ! "unallocated means no nulls" convention governs an INPUT, where unallocated is ! the caller declining to supply information; an output they explicitly asked ! for is a direct question, and answering it with an unallocated array would ! force `if (allocated(...))` around every use. if (present(sorted_valid)) then allocate(sorted_valid(n)) sorted_valid = .true. if (present(is_valid)) then do k = 1_int64, n sorted_valid(k) = is_valid(perm(k)) end do end if end if end procedure sort_i32 ! module procedure sort_i64 type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_i64(values, buf, desc, nlo, "pf_sort", is_valid=is_valid, threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do ! Deliberately ALLOCATED even when `is_valid` was absent. The module's ! "unallocated means no nulls" convention governs an INPUT, where unallocated is ! the caller declining to supply information; an output they explicitly asked ! for is a direct question, and answering it with an unallocated array would ! force `if (allocated(...))` around every use. if (present(sorted_valid)) then allocate(sorted_valid(n)) sorted_valid = .true. if (present(is_valid)) then do k = 1_int64, n sorted_valid(k) = is_valid(perm(k)) end do end if end if end procedure sort_i64 ! module procedure sort_f32 type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_f32(values, buf, desc, nlo, "pf_sort", is_valid=is_valid, threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do ! Deliberately ALLOCATED even when `is_valid` was absent. The module's ! "unallocated means no nulls" convention governs an INPUT, where unallocated is ! the caller declining to supply information; an output they explicitly asked ! for is a direct question, and answering it with an unallocated array would ! force `if (allocated(...))` around every use. if (present(sorted_valid)) then allocate(sorted_valid(n)) sorted_valid = .true. if (present(is_valid)) then do k = 1_int64, n sorted_valid(k) = is_valid(perm(k)) end do end if end if end procedure sort_f32 ! module procedure sort_f64 type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_f64(values, buf, desc, nlo, "pf_sort", is_valid=is_valid, threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do ! Deliberately ALLOCATED even when `is_valid` was absent. The module's ! "unallocated means no nulls" convention governs an INPUT, where unallocated is ! the caller declining to supply information; an output they explicitly asked ! for is a direct question, and answering it with an unallocated array would ! force `if (allocated(...))` around every use. if (present(sorted_valid)) then allocate(sorted_valid(n)) sorted_valid = .true. if (present(is_valid)) then do k = 1_int64, n sorted_valid(k) = is_valid(perm(k)) end do end if end if end procedure sort_f64 ! module procedure sort_bool type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_bool(values, buf, desc, nlo, "pf_sort", is_valid=is_valid, threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do ! Deliberately ALLOCATED even when `is_valid` was absent. The module's ! "unallocated means no nulls" convention governs an INPUT, where unallocated is ! the caller declining to supply information; an output they explicitly asked ! for is a direct question, and answering it with an unallocated array would ! force `if (allocated(...))` around every use. if (present(sorted_valid)) then allocate(sorted_valid(n)) sorted_valid = .true. if (present(is_valid)) then do k = 1_int64, n sorted_valid(k) = is_valid(perm(k)) end do end if end if end procedure sort_bool ! module procedure sort_chr type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_chr(values, buf, desc, nlo, "pf_sort", is_valid=is_valid, threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(character(len=len(values)) :: sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do ! Deliberately ALLOCATED even when `is_valid` was absent. The module's ! "unallocated means no nulls" convention governs an INPUT, where unallocated is ! the caller declining to supply information; an output they explicitly asked ! for is a direct question, and answering it with an unallocated array would ! force `if (allocated(...))` around every use. if (present(sorted_valid)) then allocate(sorted_valid(n)) sorted_valid = .true. if (present(is_valid)) then do k = 1_int64, n sorted_valid(k) = is_valid(perm(k)) end do end if end if end procedure sort_chr ! module procedure sort_date type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_date(values, buf, desc, nlo, "pf_sort", threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do end procedure sort_date ! module procedure sort_time type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_time(values, buf, desc, nlo, "pf_sort", threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do end procedure sort_time ! module procedure sort_ts type(sort_key_buf), allocatable :: buf(:) integer(int64), allocatable :: perm(:) integer(int64) :: k, n logical :: desc, nlo ! desc = .false. if (present(descending)) desc = descending nlo = .false. if (present(nulls_first)) nlo = nulls_first n = size(values, kind=int64) call extract_ts(values, buf, desc, nlo, "pf_sort", threads=threads) call drive_engine(buf, n, "pf_sort", perm, threads=threads) allocate(sorted(n)) do k = 1_int64, n sorted(k) = values(perm(k)) end do end procedure sort_ts ! end submodule parquet_sorting_argsort ! GCOVR_EXCL_LINE