Enum MetricValue 

pub enum MetricValue {
    OutputRows(Count),
    ElapsedCompute(Time),
    SpillCount(Count),
    SpilledBytes(Count),
    OutputBytes(Count),
    SpilledRows(Count),
    CurrentMemoryUsage(Gauge),
    Count {
        name: Cow<'static, str>,
        count: Count,
    },
    Gauge {
        name: Cow<'static, str>,
        gauge: Gauge,
    },
    Time {
        name: Cow<'static, str>,
        time: Time,
    },
    StartTimestamp(Timestamp),
    EndTimestamp(Timestamp),
    PruningMetrics {
        name: Cow<'static, str>,
        pruning_metrics: PruningMetrics,
    },
    Ratio {
        name: Cow<'static, str>,
        ratio_metrics: RatioMetrics,
    },
    Custom {
        name: Cow<'static, str>,
        value: Arc<dyn CustomMetricValue>,
    },
}

Possible values for a super::Metric.

Among other differences, the metric types have different ways to logically interpret their underlying values and some metrics are so common they are given special treatment.

Variants

OutputRows(Count)

Number of output rows produced: “output_rows” metric

ElapsedCompute(Time)

Elapsed Compute Time: the wall clock time spent in “cpu intensive” work.

This measurement represents, roughly:

use std::time::Instant;
let start = Instant::now();
// ...CPU intensive work here...
let elapsed_compute = (Instant::now() - start).as_nanos();

Note 1: Does not include time other operators spend computing input.

Note 2: Does includes time when the thread could have made progress but the OS did not schedule it (e.g. due to CPU contention), thus making this value different than the classical definition of “cpu_time”, which is the time reported from clock_gettime(CLOCK_THREAD_CPUTIME_ID, ..).

SpillCount(Count)

Number of spills produced: “spill_count” metric

SpilledBytes(Count)

Total size of spilled bytes produced: “spilled_bytes” metric

OutputBytes(Count)

Total size of output bytes produced: “output_bytes” metric

SpilledRows(Count)

Total size of spilled rows produced: “spilled_rows” metric

CurrentMemoryUsage(Gauge)

Current memory used

Count

Operator defined count.

Fields

name: Cow<'static, str>

The provided name of this metric

count: Count

The value of the metric

Gauge

Operator defined gauge.

Fields

name: Cow<'static, str>

The provided name of this metric

gauge: Gauge

The value of the metric

Time

Operator defined time

Fields

name: Cow<'static, str>

The provided name of this metric

time: Time

The value of the metric

StartTimestamp(Timestamp)

The time at which execution started

EndTimestamp(Timestamp)

The time at which execution ended

PruningMetrics

Metrics related to scan pruning

Fields

name: Cow<'static, str>

pruning_metrics: PruningMetrics

Ratio

Metrics that should be displayed as ratio like (42%)

Fields

name: Cow<'static, str>

ratio_metrics: RatioMetrics

Custom

Fields

name: Cow<'static, str>

The provided name of this metric

value: Arc<dyn CustomMetricValue>

A custom implementation of the metric value.

Implementations

impl MetricValue

pub fn name(&self) -> &str

Return the name of this SQL metric

pub fn as_usize(&self) -> usize

Return the value of the metric as a usize value, used to aggregate metric value across partitions.

pub fn new_empty(&self) -> Self

create a new MetricValue with the same type as self suitable for accumulating

pub fn aggregate(&mut self, other: &Self)

Aggregates the value of other to self. panic’s if the types are mismatched or aggregating does not make sense for this value

Note this is purposely marked mut (even though atomics are used) so Rust’s type system can be used to ensure the appropriate API access. MetricValues should be modified using the original Count or Time they were created from.

pub fn display_sort_key(&self) -> u8

Returns a number by which to sort metrics by display. Lower numbers are “more useful” (and displayed first)

pub fn is_timestamp(&self) -> bool

returns true if this metric has a timestamp value

Trait Implementations

impl Clone for MetricValue

fn clone(&self) -> MetricValue

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MetricValue

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

Formats the value using the given formatter.

impl Display for MetricValue

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

Prints the value of this metric

impl PartialEq for MetricValue

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.