use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
#[test]
fn deferred_callback_admission_precedes_boxing_and_tracks_invocation_or_close() {
use std::sync::Arc;
use uqa_core::{memory::MemoryBudget, CancellationToken};
struct Capture {
payload: [u8; 8192],
drops: Arc<AtomicUsize>,
}
impl Drop for Capture {
fn drop(&mut self) {
self.drops.fetch_add(1, Ordering::SeqCst);
}
}
let original = CancellationToken::new();
let invoking = CancellationToken::new();
for mode in 0..4 {
let calls = AtomicUsize::new(0);
let drops = Arc::new(AtomicUsize::new(0));
let capture = Capture {
payload: [7; 8192],
drops: drops.clone(),
};
let pending = || {
assert_eq!(capture.payload[0], 7);
drop(capture);
calls.fetch_add(1, Ordering::SeqCst);
assert!(mode != 3, "callback unwind");
Ok(
Box::new(TableScan::from_physical_rows(RowSchema::default(), vec![]))
as Box<dyn PhysicalOperator>,
)
};
let callback_bytes = size_of_val(&pending);
assert!(callback_bytes >= 8192);
let bytes = callback_bytes + size_of::<DeferredOperator<'_>>();
let budget = MemoryBudget::new(bytes - usize::from(mode == 0));
let control = ProductionControl::new(&budget, &original, &invoking);
let mut result = None;
let allocation = allocation_counter::measure(|| {
result = Some(DeferredOperator::from_bound_schema_with_control(
Some(RowSchema::default()),
pending,
&control,
));
});
if mode == 0 {
assert_eq!(result.unwrap().err().unwrap().sqlstate(), Some("53200"));
assert!(allocation.bytes_total < 4096, "{allocation:?}");
} else {
let mut scan = result.unwrap().unwrap();
assert_eq!(budget.used(), bytes);
scan.open().unwrap();
assert_eq!(calls.load(Ordering::SeqCst), 0);
if mode == 1 {
assert!(scan.next().unwrap().is_none());
assert_eq!(budget.used(), size_of::<DeferredOperator<'_>>());
} else if mode == 3 {
assert!(
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| scan.next())).is_err()
);
assert_eq!(budget.used(), size_of::<DeferredOperator<'_>>());
}
scan.close().unwrap();
assert_eq!(budget.used(), size_of::<DeferredOperator<'_>>());
}
assert_eq!(drops.load(Ordering::SeqCst), 1);
assert_eq!(
calls.load(Ordering::SeqCst),
usize::from(mode == 1 || mode == 3)
);
assert_eq!(budget.used(), 0);
}
let budget = MemoryBudget::new(0);
let control = ProductionControl::new(&budget, &original, &invoking);
let calls = AtomicUsize::new(0);
for token in [&original, &invoking] {
token.cancel();
let result = DeferredOperator::from_bound_schema_with_control(
None,
|| {
calls.fetch_add(1, Ordering::SeqCst);
Ok(Box::new(TableScan::from_physical_rows(
RowSchema::default(),
vec![],
)))
},
&control,
);
assert_eq!(result.err().unwrap().sqlstate(), Some("57014"));
token.reset();
}
assert_eq!(calls.load(Ordering::SeqCst), 0);
}
#[test]
fn runtime_column_binding_preserves_deferred_closed_descriptors() {
for open in [false, true] {
let calls = AtomicUsize::new(0);
let runtime = RowSchema::with_types(
vec!["value".into()],
vec![Some(uqa_sql::ColumnType::Integer)],
);
let bound = if open {
RowSchema::with_open_columns(&RowSchema::default(), None)
} else {
runtime.clone()
};
let mut scan = DeferredOperator::from_bound_schema(
Some(bound),
Box::new(|| {
calls.fetch_add(1, Ordering::SeqCst);
Ok(Box::new(TableScan::from_physical_rows(
runtime,
vec![crate::PhysicalRow::from_values(vec![uqa_core::Value::Int(
7,
)])],
)))
}),
)
.unwrap();
assert_eq!(calls.load(Ordering::SeqCst), usize::from(open));
assert_eq!(scan.schema(), &["value".to_string()]);
let (_, rows) = crate::physical::run_to_rows(scan.as_mut()).unwrap();
assert_eq!(rows[0]["value"], uqa_core::Value::Int(7));
assert_eq!(calls.load(Ordering::SeqCst), 1);
}
}
#[test]
fn physical_output_binding_keeps_scores_outside_public_columns() {
let column = uqa_sql::ast::InternalRelationId::allocate().column(0);
let schema = RowSchema::new(vec!["id".into()]);
let schema = RowSchema::append_internal_typed(
&schema,
&[(column, Some(uqa_sql::ColumnType::DoublePrecision))],
);
let schema = RowSchema::with_score_source(&schema, Some("hit"), column);
let calls = AtomicUsize::new(0);
let mut output = DeferredOperator::from_bound_schema(
None,
Box::new(|| {
calls.fetch_add(1, Ordering::SeqCst);
Ok(Box::new(TableScan::from_physical_rows(
schema.clone(),
vec![],
)))
}),
)
.unwrap();
assert_eq!(calls.load(Ordering::SeqCst), 1);
assert_eq!(output.row_schema(), &schema);
assert_eq!(
output.row_schema().score_sources().collect::<Vec<_>>(),
[(Some("hit"), column)]
);
output.open().unwrap();
assert!(output.next().unwrap().is_none());
output.close().unwrap();
assert_eq!(calls.load(Ordering::SeqCst), 1);
}
#[test]
fn deferred_sources_run_once_on_pull_and_remain_unused_when_closed_without_rows() {
for pull in [false, true] {
let calls = AtomicUsize::new(0);
let mut scan = DeferredOperator::from_rows(
RowSchema::default(),
Box::new(|| {
calls.fetch_add(1, Ordering::SeqCst);
Ok(Box::new(crate::scan::VecSource::with_row_schema(
RowSchema::default(),
vec![],
)))
}),
);
scan.open().unwrap();
assert_eq!(calls.load(Ordering::SeqCst), 0);
if pull {
assert!(scan.next().unwrap().is_none());
assert!(scan.next().unwrap().is_none());
}
scan.close().unwrap();
assert_eq!(calls.load(Ordering::SeqCst), usize::from(pull));
}
}
#[test]
fn deferred_source_failures_keep_sqlstate_and_never_repeat_the_producer() {
let calls = AtomicUsize::new(0);
let mut scan = DeferredOperator::from_rows(
RowSchema::default(),
Box::new(|| {
calls.fetch_add(1, Ordering::SeqCst);
Err(SQLError::Routine {
sqlstate: "40001".into(),
message: "retained participant completed".into(),
})
}),
);
scan.open().unwrap();
let error = scan.next().unwrap_err();
assert!(
matches!(error, crate::ExecError::SQL(SQLError::Routine { ref sqlstate, .. }) if sqlstate == "40001")
);
assert!(scan.next().is_err());
scan.close().unwrap();
assert_eq!(calls.load(Ordering::SeqCst), 1);
}
#[test]
fn failed_operator_initialization_cannot_be_pulled_and_is_still_closed() {
struct FailedOpen<'a> {
schema: RowSchema,
opened: &'a AtomicUsize,
closed: &'a AtomicUsize,
}
impl PhysicalOperator for FailedOpen<'_> {
fn row_schema(&self) -> &RowSchema {
&self.schema
}
fn open(&mut self) -> ExecResult<()> {
self.opened.fetch_add(1, Ordering::SeqCst);
Err(SQLError::Routine {
sqlstate: "40001".into(),
message: "initialization failed".into(),
}
.into())
}
fn next(&mut self) -> ExecResult<Option<Batch>> {
panic!("failed input must not be pulled")
}
fn close(&mut self) -> ExecResult<()> {
self.closed.fetch_add(1, Ordering::SeqCst);
Ok(())
}
}
let opened = AtomicUsize::new(0);
let closed = AtomicUsize::new(0);
let mut operator = DeferredOperator::new(
RowSchema::default(),
Box::new(|| {
Ok(Box::new(FailedOpen {
schema: RowSchema::default(),
opened: &opened,
closed: &closed,
}))
}),
);
operator.open().unwrap();
assert_eq!(opened.load(Ordering::SeqCst), 0);
assert!(
matches!(operator.next(), Err(crate::ExecError::SQL(SQLError::Routine { sqlstate, .. })) if sqlstate == "40001")
);
assert!(operator.next().is_err());
operator.close().unwrap();
assert_eq!(opened.load(Ordering::SeqCst), 1);
assert_eq!(closed.load(Ordering::SeqCst), 1);
}
#[test]
fn rejected_deferred_descriptor_closes_the_created_input_once() {
struct Input<'a> {
schema: RowSchema,
closed: &'a AtomicUsize,
}
impl PhysicalOperator for Input<'_> {
fn row_schema(&self) -> &RowSchema {
&self.schema
}
fn open(&mut self) -> ExecResult<()> {
panic!("descriptor rejected before open")
}
fn next(&mut self) -> ExecResult<Option<Batch>> {
panic!("descriptor rejected before pull")
}
fn close(&mut self) -> ExecResult<()> {
assert_eq!(self.closed.fetch_add(1, Ordering::SeqCst), 0);
Err(SQLError::Routine {
sqlstate: "58030".into(),
message: "deferred input close failed".into(),
}
.into())
}
}
let closed = AtomicUsize::new(0);
let mut operator = DeferredOperator::new(
RowSchema::default(),
Box::new(|| {
Ok(Box::new(Input {
schema: RowSchema::new(vec!["unexpected".into()]),
closed: &closed,
}))
}),
);
operator.open().unwrap();
let error = crate::physical::physical_exec_error(operator.next().unwrap_err());
assert_eq!(error.sqlstate(), Some("XX000"));
assert!(error.to_string().contains("changed its bound row schema"));
assert!(error
.detail()
.unwrap()
.contains("deferred input close failed"));
operator.close().unwrap();
operator.close().unwrap();
assert_eq!(closed.load(Ordering::SeqCst), 1);
}