uqa-execution 0.6.2

Volcano physical operators with row-batch pipelines
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use super::*;

thread_local! {
    static CLOCK: Cell<(Instant, Duration, u64)> = Cell::new((Instant::now(), Duration::ZERO, 0));
}

fn now() -> Instant {
    CLOCK.with(|clock| {
        let (base, elapsed, calls) = clock.get();
        clock.set((base, elapsed, calls + 1));
        base + elapsed
    })
}

fn advance(millis: u64) {
    CLOCK.with(|clock| {
        let (base, elapsed, calls) = clock.get();
        clock.set((base, elapsed + Duration::from_millis(millis), calls));
    });
}

fn measurement(timing: bool) -> QueryMeasurement {
    CLOCK.with(|clock| clock.set((Instant::now(), Duration::ZERO, 0)));
    let mut measurement =
        QueryMeasurement::new(timing, &uqa_core::memory::MemoryBudget::new(65_536));
    if timing {
        measurement.clock = Some(now);
    }
    measurement
}

#[test]
fn first_produced_row_excludes_all_completed_destination_work() {
    let measurement = measurement(true);
    measurement
        .run(|| {
            advance(10);
            measurement.output(1, || {
                advance(100);
                Ok(())
            })?;
            advance(20);
            measurement.output(2, || {
                advance(50);
                Ok(())
            })?;
            advance(5);
            Ok(())
        })
        .unwrap();
    assert_eq!(
        measurement.metrics(),
        ExplainNodeMetrics {
            rows: 3,
            loops: 1,
            startup: Duration::from_millis(10),
            total: Duration::from_millis(35),
        }
    );
}

#[test]
fn empty_delivery_does_not_establish_startup_and_never_run_has_no_loop() {
    let measurement = measurement(true);
    assert_eq!(measurement.metrics(), ExplainNodeMetrics::default());
    measurement
        .run(|| {
            advance(5);
            measurement.output(0, || {
                advance(7);
                Ok(())
            })?;
            advance(11);
            Ok(())
        })
        .unwrap();
    assert_eq!(
        measurement.metrics(),
        ExplainNodeMetrics {
            rows: 0,
            loops: 1,
            startup: Duration::from_millis(16),
            total: Duration::from_millis(16),
        }
    );
}

#[test]
fn initial_empty_batches_leave_startup_for_the_first_nonempty_batch() {
    let measurement = measurement(true);
    measurement
        .run(|| {
            advance(5);
            measurement.output(0, || {
                advance(7);
                Ok(())
            })?;
            advance(11);
            measurement.output(2, || {
                advance(17);
                Ok(())
            })?;
            advance(3);
            Ok(())
        })
        .unwrap();
    assert_eq!(measurement.metrics().startup, Duration::from_millis(16));
    assert_eq!(measurement.metrics().total, Duration::from_millis(19));
}

#[test]
fn untimed_invocations_count_loops_and_rows_without_clock_reads_or_allocations() {
    let measurement = measurement(false);
    let allocations = allocation_counter::measure(|| {
        for _ in 0..1000 {
            measurement
                .run(|| measurement.output(7, || Ok(())))
                .unwrap();
        }
    });
    assert_eq!(allocations.count_total, 0);
    assert_eq!(
        measurement.metrics(),
        ExplainNodeMetrics {
            rows: 7000,
            loops: 1000,
            ..ExplainNodeMetrics::default()
        }
    );
    assert_eq!(CLOCK.with(|clock| clock.get().2), 0);
}

#[test]
fn completed_invocations_accumulate_without_reusing_startup() {
    let measurement = measurement(true);
    for delay in [5, 13] {
        measurement
            .run(|| {
                advance(delay);
                measurement.output(1, || Ok(()))?;
                advance(2);
                Ok(())
            })
            .unwrap();
    }
    assert_eq!(
        measurement.metrics(),
        ExplainNodeMetrics {
            rows: 2,
            loops: 2,
            startup: Duration::from_millis(18),
            total: Duration::from_millis(22),
        }
    );
}

#[test]
fn row_overflow_does_not_replace_the_last_count_or_invoke_the_sink() {
    let measurement = measurement(false);
    measurement
        .run(|| {
            let mut running = measurement.running.get().unwrap();
            running.rows = u64::MAX;
            measurement.running.set(Some(running));
            assert!(measurement
                .output::<()>(1, || panic!("overflow reached destination"))
                .is_err());
            assert_eq!(measurement.running.get().unwrap().rows, u64::MAX);
            Ok(())
        })
        .unwrap();
    assert_eq!(measurement.metrics().rows, u64::MAX);
}

#[test]
fn original_execution_error_survives_completion_overflow() {
    let measurement = measurement(false);
    let original = ExplainNodeMetrics {
        loops: u64::MAX,
        ..ExplainNodeMetrics::default()
    };
    measurement.completed.set(original);
    let error = measurement
        .run::<()>(|| {
            Err(SQLError::Routine {
                sqlstate: "22012".into(),
                message: "source failure".into(),
            })
        })
        .unwrap_err();
    assert_eq!(error.sqlstate(), Some("22012"));
    assert!(error.to_string().contains("source failure"));
    assert_eq!(measurement.metrics(), original);
    assert!(measurement.running.get().is_none());
}

#[test]
fn rejected_reentry_and_unwinding_restore_the_invocation_owner() {
    let measurement = measurement(false);
    measurement
        .run(|| {
            assert!(measurement.run(|| Ok(())).is_err());
            measurement.output(1, || Ok(()))
        })
        .unwrap();
    let original = measurement.metrics();
    let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        let _ = measurement.run::<()>(|| panic!("source panic"));
    }));
    assert!(panic.is_err());
    assert_eq!(measurement.metrics(), original);
    assert!(measurement.running.get().is_none());
    measurement.run(|| Ok(())).unwrap();
    assert_eq!(measurement.metrics().loops, 2);
}

#[test]
fn a_backwards_clock_keeps_the_original_error_and_releases_the_invocation() {
    let measurement = measurement(true);
    advance(10);
    let error = measurement
        .run::<()>(|| {
            CLOCK.with(|clock| {
                let (base, _, calls) = clock.get();
                clock.set((base, Duration::from_millis(5), calls));
            });
            Err(SQLError::Routine {
                sqlstate: "22012".into(),
                message: "original producer error".into(),
            })
        })
        .unwrap_err();
    assert_eq!(error.sqlstate(), Some("22012"));
    assert!(error.detail().unwrap().contains("measurements overflowed"));
    assert_eq!(measurement.metrics(), ExplainNodeMetrics::default());
    assert!(measurement.running.get().is_none());
}