use super::*;
use uqa_core::{memory::MemoryBudget, CancellationToken};
use uqa_sql::plan::{QueryPlan, RetainedCtePlan, UnifiedPlan};
fn query(sql: &str) -> QueryPlan {
let UnifiedPlan::Query(query) = UnifiedPlan::lower(uqa_sql::compile(sql).unwrap().remove(0))
else {
panic!("query");
};
*query
}
fn declaration(sql: &str) -> RetainedCtePlan {
query(sql).ctes.remove(0).into()
}
fn rows() -> crate::SharedSpill {
crate::SpillBuffer::new(4096)
.into_shared(crate::RowSchema::new(vec!["n".into()]))
.unwrap()
}
#[test]
fn lexical_copy_rejects_before_allocating_names_and_keeps_shared_inputs_alive() {
let mut definition = query("WITH q AS (SELECT 1) SELECT 1").ctes.remove(0);
definition.name = "x".repeat(4 << 20);
let mut source = CteScope::<()>::new();
source.insert_deferred(definition.into());
let budget = MemoryBudget::new(4096);
let original = CancellationToken::new();
let invoking = CancellationToken::new();
let control = ProductionControl::new(&budget, &original, &invoking);
let measured = allocation_counter::measure(|| {
assert_eq!(
source.copy_with_control(&control).err().unwrap().sqlstate(),
Some("53200")
);
});
assert!(measured.bytes_total < 16 << 10, "{measured:?}");
assert_eq!(budget.used(), 0);
drop(source);
let budget = MemoryBudget::new(1 << 20);
let control = ProductionControl::new(&budget, &original, &invoking);
let mut source = CteScope::<()>::empty_with_control(&control).unwrap();
source
.insert_deferred_with_control(declaration("WITH q AS (SELECT 1) SELECT 1"), &control)
.unwrap();
source
.insert_shared_with_control("rows", rows(), &control)
.unwrap();
let original_plan = source.deferred_for_scan("q").unwrap();
let before = budget.used();
let mut copy = source.copy_with_control(&control).unwrap();
assert!(budget.used() > before);
assert!(std::ptr::eq(
copy.deferred_reference("q").unwrap(),
original_plan.as_ref()
));
copy.remove_deferred("q");
copy.remove_materialized("rows");
assert!(source.deferred_reference("q").is_some());
assert!(source.rows.contains_key("rows"));
for token in [&original, &invoking] {
token.cancel();
let held = budget.used();
assert_eq!(
source.copy_with_control(&control).err().unwrap().sqlstate(),
Some("57014")
);
assert_eq!(budget.used(), held);
token.reset();
}
drop((source, copy, original_plan));
assert_eq!(budget.used(), 0);
}
#[test]
fn declaration_replacement_is_atomic_at_each_partial_allocation_boundary() {
let initial = query("WITH source AS (SELECT 7 AS n), q AS (SELECT 9 AS n) SELECT 1");
let replacement = declaration("WITH q AS (SELECT n FROM source) SELECT 1");
let mut failed = 0;
let mut succeeded = 0;
for available in [0, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384] {
let budget = MemoryBudget::new(1 << 20);
let token = CancellationToken::new();
let control = ProductionControl::new(&budget, &token, &token);
let mut scope = CteScope::<()>::empty_with_control(&control).unwrap();
for definition in &initial.ctes {
scope
.insert_deferred_with_control(definition.clone().into(), &control)
.unwrap();
}
let before = budget.used();
let original = scope.deferred_for_scan("q").unwrap();
let original_definition = Arc::clone(scope.definition_scopes.get("q").unwrap());
let occupied = budget.reserve(budget.available() - available).unwrap();
match scope.insert_preparation_cte_with_control(replacement.clone(), false, &control) {
Err(error) => {
failed += 1;
assert_eq!(error.sqlstate(), Some("53200"));
assert!(std::ptr::eq(
scope.deferred_reference("q").unwrap(),
original.as_ref()
));
assert!(Arc::ptr_eq(
scope.definition_scopes.get("q").unwrap(),
&original_definition
));
assert!(scope.cte_is_folded("q"));
assert!(!scope.non_returning_ctes.contains("q"));
assert_eq!(budget.used(), before + occupied.bytes());
}
Ok(()) => {
succeeded += 1;
assert!(std::ptr::eq(
scope.deferred_reference("q").unwrap(),
replacement.as_ref()
));
assert!(!scope.cte_is_folded("q"));
}
}
drop((occupied, scope, original, original_definition));
assert_eq!(budget.used(), 0);
}
assert!(
failed >= 3 && succeeded >= 1,
"failed={failed}, succeeded={succeeded}"
);
}
#[test]
fn lexical_guards_restore_only_selected_names_without_allocation_even_when_cancelled() {
let budget = MemoryBudget::new(1 << 20);
let token = CancellationToken::new();
let control = ProductionControl::new(&budget, &token, &token);
let mut scope = CteScope::<()>::empty_with_control(&control).unwrap();
scope
.insert_deferred_with_control(declaration("WITH q AS (SELECT 7 AS n) SELECT 1"), &control)
.unwrap();
let original = scope.deferred_for_scan("q").unwrap();
let materialized = rows();
{
let mut guard = scope
.enter_cte_bindings_with_control(["q"], &control)
.unwrap();
guard
.insert_shared_with_control("q", materialized.clone(), &control)
.unwrap();
guard
.insert_shared_with_control("progress", materialized.clone(), &control)
.unwrap();
let occupied = budget.reserve(budget.available()).unwrap();
token.cancel();
let allocation = allocation_counter::measure(|| drop(guard));
assert_eq!(allocation.count_total, 0, "{allocation:?}");
drop(occupied);
token.reset();
}
assert!(std::ptr::eq(
scope.deferred_reference("q").unwrap(),
original.as_ref()
));
assert!(scope.rows.contains_key("progress"));
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let mut guard = scope
.enter_cte_bindings_with_control(["q"], &control)
.unwrap();
guard
.insert_shared_with_control("q", materialized, &control)
.unwrap();
panic!("unwind lexical binding");
}));
assert!(result.is_err());
assert!(std::ptr::eq(
scope.deferred_reference("q").unwrap(),
original.as_ref()
));
assert!(scope.rows.contains_key("progress"));
drop((scope, original));
assert_eq!(budget.used(), 0);
}
#[test]
fn definition_scope_copies_only_selected_names_and_preserves_quoted_identity() {
let mut scope = CteScope::<()>::new();
for cte in
query("WITH source AS (SELECT 7 AS n), selected AS (SELECT n FROM source) SELECT 1").ctes
{
scope.insert_deferred(cte.into());
}
let mut unused = query("WITH unused AS (SELECT 1) SELECT 1").ctes.remove(0);
unused.name = "x".repeat(4 << 20);
scope.insert_deferred(unused.into());
let budget = MemoryBudget::new(64 << 10);
let token = CancellationToken::new();
let control = ProductionControl::new(&budget, &token, &token);
let measured = allocation_counter::measure(|| {
let definition = scope
.definition_scope_with_control("selected", &control)
.unwrap()
.unwrap();
assert_eq!(definition.deferred_ctes.len(), 1);
assert!(definition.deferred_reference("source").is_some());
});
assert!(measured.bytes_total < 64 << 10, "{measured:?}");
assert_eq!(budget.used(), 0);
for (decoded, reference) in [
("Q.CTE", "\"Q.CTE\""),
("a\"b", "\"a\"\"b\""),
("한글", "한글"),
] {
let mut plan = query("WITH q AS (SELECT 1) SELECT 1").ctes.remove(0);
plan.name = decoded.into();
scope.insert_deferred(plan.into());
let occupied = budget.reserve(budget.available()).unwrap();
let measured = allocation_counter::measure(|| {
assert!(scope
.deferred_reference_with_control(reference, &control)
.unwrap()
.is_some());
assert!(scope
.is_visible_cte_with_control(reference, &control)
.unwrap());
});
assert_eq!(measured.count_total, 0, "{measured:?}");
drop(occupied);
}
}
#[test]
fn recursive_working_binding_publishes_and_restores_rows_and_width_atomically() {
let budget = MemoryBudget::new(1 << 20);
let token = CancellationToken::new();
let control = ProductionControl::new(&budget, &token, &token);
let mut scope = CteScope::<()>::empty_with_control(&control).unwrap();
scope
.insert_deferred_with_control(declaration("WITH q AS (SELECT 7 AS n) SELECT 1"), &control)
.unwrap();
scope
.recursive_control_widths
.insert_with_control("q", 7, &control)
.unwrap();
let original = scope.deferred_for_scan("q").unwrap();
let before = budget.used();
let materialized = rows();
for available in [0, 64, 128] {
let occupied = budget.reserve(budget.available() - available).unwrap();
assert_eq!(
scope
.enter_recursive_cte_with_control("q", materialized.clone(), Some(1), &control)
.err()
.unwrap()
.sqlstate(),
Some("53200")
);
assert!(std::ptr::eq(
scope.deferred_reference("q").unwrap(),
original.as_ref()
));
assert_eq!(scope.recursive_control_width("q"), Some(7));
assert_eq!(budget.used(), before + occupied.bytes());
drop(occupied);
}
let guard = scope
.enter_recursive_cte_with_control("q", materialized.clone(), Some(1), &control)
.unwrap();
assert_eq!(guard.recursive_control_width("q"), Some(1));
assert!(guard.rows.contains_key("q"));
let occupied = budget.reserve(budget.available()).unwrap();
token.cancel();
let allocation = allocation_counter::measure(|| drop(guard));
assert_eq!(allocation.count_total, 0);
token.reset();
drop(occupied);
assert_eq!(budget.used(), before);
assert!(std::ptr::eq(
scope.deferred_reference("q").unwrap(),
original.as_ref()
));
assert_eq!(scope.recursive_control_width("q"), Some(7));
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _guard = scope
.enter_recursive_cte_with_control("q", materialized, Some(1), &control)
.unwrap();
panic!("unwind recursive binding");
}));
assert!(result.is_err());
assert_eq!(scope.recursive_control_width("q"), Some(7));
assert_eq!(budget.used(), before);
drop((scope, original));
assert_eq!(budget.used(), 0);
}