Struct ConvertReport 

pub struct ConvertReport {

    pub read: Report,
    pub select: RunReport,
    pub loads: Report,
    pub summary_loads: Report,
    pub summarized: Vec<RunReport>,
    pub decided: RunReport,
    pub groups: Vec<GroupReport>,
    pub finalized: RunReport,
    pub gather_loads: Report,
    pub gather_runs: Vec<RunReport>,
    pub summary_bytes: usize,
    pub merged_summary_bytes: usize,
    pub parts: usize,
    pub part_sizes: Vec<PartSize>,
    pub counts: BTreeMap<String, u64>,
    pub part_reports: Vec<PartReport>,
    pub reported: Vec<Notice>,
    pub written: Report,
    pub stages: Vec<(String, Duration)>,
}

What a conversion did.

Fields

read: Report

The reader’s report on reading.

select: RunReport

The selection passes.

loads: Report

The reader’s reports on loading, part by part.

summary_loads: Report

In a conversion with summaries (convert_parts_summarized): the reader’s reports on loading each part for its summary, the summary passes’ report per part, and the decision passes’ report.

summarized: Vec<RunReport>

decided: RunReport

groups: Vec<GroupReport>

In a conversion with groups (convert_parts_gathered): each group’s report, in the order written, and the finalizing decision passes’ report.

finalized: RunReport

gather_loads: Report

In a conversion with groups: the reader’s reports on loading each part for the gather traversal, and the gather passes’ report per part.

gather_runs: Vec<RunReport>

summary_bytes: usize

The bytes of every part’s summaries kept until the merge (the most the first traversal holds of them), and of the merged summaries handed to every part, as the summaries state them (crate::summary::Summary::retained_bytes): logical-data accounting, not a measured or bounded memory peak.

merged_summary_bytes: usize

parts: usize

part_sizes: Vec<PartSize>

The bulk payload of every part, in the order written.

counts: BTreeMap<String, u64>

Every pass’s counts over all parts, as <pass>: <what>, and what the parts kept of what the passes made (convert: <what>). A sum of ConvertReport::part_reports, kept for callers that print totals.

part_reports: Vec<PartReport>

Each part’s reports, whole, in the order written.

reported: Vec<Notice>

What the reader and the writer noticed, in the order they reported it.

written: Report

The writer’s report.

stages: Vec<(String, Duration)>

Each stage of the conversion in the order it ran, named as ConvertError::during names it (read, select, plan, part N: load, part N: passes, part N: target check, part N: write, finish, and the summary, gather and group stages), with its wall-clock time: for a program’s log and for profiling, not part of what the conversion makes. A failed conversion’s partial report ends with the stage that failed.

Implementations

impl ConvertReport

pub fn approximations(&self) -> BTreeMap<String, u64>

Every approximation, as <pass>: <what>, over the selection and every part, from the reports kept.

pub fn notices(&self) -> Vec<Notice>

Every notice: the reader’s and the writer’s, then the passes’ approximations, omissions and drops (what they left out on purpose: a selection, <measure>: <why>), what the parts left out and what the writer doesn’t write, one notice per stage and reason over all parts, with the parts as examples.

Trait Implementations

impl Debug for ConvertReport

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ConvertReport

fn default() -> Self

Returns the “default value” for a type.