use super::test_support::{materialized, plan, Services};
use super::*;
use crate::query::scope::subqueries::{CachedCorrelatedExists, CorrelatedExistsOuterKeys};
use crate::query::CteScope;
use crate::{CanonicalRowHashSet, PhysicalRow, RowSchema, ScalarExpr};
mod typed_ranges;
#[test]
fn cached_consumers_skip_metadata_memory_and_query_contexts() {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1");
scope.cache_subquery(0, ScalarSubqueryCacheEntry::Scalar(Value::Int(7)));
scope.cache_subquery(1, ScalarSubqueryCacheEntry::Exists(true));
scope.cache_subquery(
2,
ScalarSubqueryCacheEntry::Materialized(materialized(vec![Value::Int(9)], 1)),
);
let context = services.context(&scope);
assert_eq!(
context
.scalar_subquery_value(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap(),
Value::Int(7)
);
assert!(context
.subquery_exists(1, &query, PhysicalOuterRow::Absent, &[])
.unwrap());
assert_eq!(
context
.execute_subquery(2, &query, PhysicalOuterRow::Absent, &[])
.unwrap()
.into_scalar_value()
.unwrap(),
Value::Int(9)
);
assert!(context
.subquery_exists(2, &query, PhysicalOuterRow::Absent, &[])
.unwrap());
assert!(services.events.lock().is_empty());
}
#[test]
fn a_slot_cannot_switch_to_an_incompatible_result_consumer() {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1");
scope.cache_subquery(0, ScalarSubqueryCacheEntry::Scalar(Value::Int(7)));
scope.cache_subquery(1, ScalarSubqueryCacheEntry::Exists(true));
let context = services.context(&scope);
let errors = [
context
.execute_subquery(0, &query, PhysicalOuterRow::Absent, &[])
.err()
.unwrap(),
context
.subquery_exists(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap_err(),
context
.subquery_contains(0, &query, &Value::Int(1), PhysicalOuterRow::Absent, &[])
.unwrap_err(),
context
.scalar_subquery_value(1, &query, PhysicalOuterRow::Absent, &[])
.unwrap_err(),
];
for error in errors {
assert!(
matches!(error, SQLError::Internal(message) if message == "scalar subquery slot changed result consumer during execution")
);
}
assert!(services.events.lock().is_empty());
}
#[test]
fn failed_membership_promotion_preserves_materialized_rows() {
let services = Services {
fail_memory: true,
..Services::default()
};
let scope = CteScope::new();
let query = plan("SELECT 1");
scope.cache_subquery(
0,
ScalarSubqueryCacheEntry::Materialized(materialized(vec![Value::Int(7)], 1)),
);
let error = services
.context(&scope)
.subquery_contains(0, &query, &Value::Int(7), PhysicalOuterRow::Absent, &[])
.unwrap_err();
assert!(
matches!(error, SQLError::Internal(message) if message == "memory setting unavailable")
);
assert!(matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::Materialized(_))
));
assert_eq!(*services.events.lock(), ["memory"]);
assert_eq!(
services
.context(&scope)
.scalar_subquery_value(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap(),
Value::Int(7)
);
}
#[test]
fn membership_promotion_preserves_null_semantics_and_reuses_the_set() {
for budget in [1, usize::MAX] {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1");
scope.cache_subquery(
0,
ScalarSubqueryCacheEntry::Materialized(materialized(
vec![Value::Int(7), Value::Null],
budget,
)),
);
let context = services.context(&scope);
for (needle, expected) in [
(Value::Int(7), Some(true)),
(Value::Int(8), None),
(Value::Null, None),
] {
assert_eq!(
context
.subquery_contains(0, &query, &needle, PhysicalOuterRow::Absent, &[])
.unwrap(),
expected
);
}
assert!(matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::Membership(_))
));
assert_eq!(*services.events.lock(), ["memory"]);
}
}
#[test]
fn scalar_cardinality_error_does_not_replace_the_materialized_cache() {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1");
scope.cache_subquery(
0,
ScalarSubqueryCacheEntry::Materialized(materialized(vec![Value::Int(1), Value::Int(2)], 1)),
);
let error = services
.context(&scope)
.scalar_subquery_value(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap_err();
assert!(matches!(error, SQLError::Routine { sqlstate, .. } if sqlstate == "21000"));
assert!(matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::Materialized(_))
));
assert!(services.events.lock().is_empty());
}
#[test]
fn correlation_is_cached_before_a_missing_outer_row_fails() {
let mut services = Services {
allow_metadata: true,
..Services::default()
};
let scope = CteScope::new();
let query = plan("SELECT outer_value");
for first in [true, false] {
let error = services
.context(&scope)
.scalar_subquery_value(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap_err();
assert!(
matches!(error, SQLError::Internal(message) if message == "correlated subquery reached execution without a positional outer row")
);
assert!(matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::Correlated)
));
assert_eq!(
*services.events.lock(),
if first {
vec!["catalog", "resolution"]
} else {
Vec::new()
}
);
services.events.lock().clear();
services.allow_metadata = false;
}
}
fn cache_keys(scope: &CteScope, expressions: Vec<ScalarExpr>) {
let mut keys = CanonicalRowHashSet::new();
keys.insert_values(&[Value::Int(7)]).unwrap();
scope.cache_subquery(
0,
ScalarSubqueryCacheEntry::CorrelatedExists(Arc::new(CachedCorrelatedExists {
outer_keys: CorrelatedExistsOuterKeys::compile(expressions),
keys,
})),
);
}
#[test]
fn direct_exists_keys_resolve_qualified_columns_and_skip_missing_or_null_values() {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1");
cache_keys(
&scope,
vec![ScalarExpr::QualifiedColumn {
qualifier: "outer_row".into(),
column: "id".into(),
}],
);
for (column, value, expected) in [
("id", Value::Int(7), true),
("id", Value::Int(8), false),
("id", Value::Null, false),
("other", Value::Int(7), false),
] {
let schema = RowSchema::with_qualified_types("outer_row", vec![column.into()], vec![None]);
let row = PhysicalRow::from_values(vec![value]);
assert_eq!(
services
.context(&scope)
.subquery_exists(
0,
&query,
PhysicalOuterRow::Physical {
schema: &schema,
row: &row
},
&[]
)
.unwrap(),
expected
);
}
assert!(services.events.lock().is_empty());
}
#[test]
fn evaluated_exists_keys_use_scoped_function_and_subquery_callbacks() {
let services = Services::default();
let mut scope = CteScope::new();
let query = plan("SELECT 1");
scope.scalar_subqueries = vec![query.clone()].into();
let schema = RowSchema::new(vec![]);
let row = PhysicalRow::from_values(vec![]);
let outer = PhysicalOuterRow::Physical {
schema: &schema,
row: &row,
};
for (expression, expected_event) in [
(
ScalarExpr::Func {
order_syntax: uqa_sql::ast::FunctionOrderSyntax::Ordinary,
name: "key_value".into(),
args: vec![],
distinct: false,
filter: None,
order_by: vec![],
binding: None,
},
"key",
),
(ScalarExpr::ScalarSubquery(0), "nested"),
] {
cache_keys(&scope, vec![expression]);
assert!(services
.context(&scope)
.subquery_exists(0, &query, outer, &[])
.unwrap());
assert_eq!(*services.events.lock(), [expected_event]);
services.events.lock().clear();
}
}
#[test]
fn null_exists_key_stops_before_evaluating_later_subqueries() {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1");
cache_keys(
&scope,
vec![
ScalarExpr::Literal(Value::Null),
ScalarExpr::ScalarSubquery(99),
],
);
let schema = RowSchema::new(vec![]);
let row = PhysicalRow::from_values(vec![]);
assert!(!services
.context(&scope)
.subquery_exists(
0,
&query,
PhysicalOuterRow::Physical {
schema: &schema,
row: &row
},
&[]
)
.unwrap());
let error = services
.context(&scope)
.subquery_exists(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap_err();
assert!(
matches!(error, SQLError::Internal(message) if message == "correlated subquery requires an outer row")
);
assert!(services.events.lock().is_empty());
}
#[test]
fn predicate_preparation_checks_shape_slot_and_volatility_before_catalog_capture() {
let services = Services::default();
let mut scope = CteScope::new();
assert!(prepare_correlated_exists_predicate(
&services.services(),
&ScalarExpr::Literal(Value::Bool(true)),
&[],
&scope
)
.unwrap()
.is_none());
let expression = ScalarExpr::Exists {
subquery: 0,
negated: false,
};
let error = prepare_correlated_exists_predicate(&services.services(), &expression, &[], &scope)
.err()
.unwrap();
assert!(
matches!(error, SQLError::Internal(message) if message == "physical scalar subquery slot 0 is out of bounds")
);
assert!(services.events.lock().is_empty());
scope.scalar_subqueries = vec![plan("SELECT volatile_value()")].into();
assert!(
prepare_correlated_exists_predicate(&services.services(), &expression, &[], &scope)
.unwrap()
.is_none()
);
assert_eq!(*services.events.lock(), ["volatility"]);
}
#[test]
fn grouped_row_cache_preserves_positional_columns_without_reexecution() {
let services = Services::default();
let scope = CteScope::new();
let query = plan("SELECT 1 AS value, 2 AS value");
let row = crate::OwnedPhysicalRow::new(
RowSchema::new(vec!["value".into(), "value".into()]),
PhysicalRow::from_values(vec![Value::Int(1), Value::Int(2)]),
);
scope.cache_subquery(0, ScalarSubqueryCacheEntry::Row(Some(row)));
scope.cache_subquery(1, ScalarSubqueryCacheEntry::Row(None));
let context = services.context(&scope);
for _ in 0..2 {
let row = context
.row_subquery_value(0, &query, PhysicalOuterRow::Absent, &[])
.unwrap()
.unwrap();
assert_eq!(row.view().value_at(0), Some(&Value::Int(1)));
assert_eq!(row.view().value_at(1), Some(&Value::Int(2)));
assert!(context
.row_subquery_value(1, &query, PhysicalOuterRow::Absent, &[])
.unwrap()
.is_none());
}
assert!(services.events.lock().is_empty());
}
#[test]
fn grouped_row_consumer_does_not_pull_past_the_second_row() {
let count = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let observed = Arc::clone(&count);
let rows = (0..5).map(move |value| {
observed.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
Ok(crate::OwnedPhysicalRow::new(
RowSchema::new(vec!["value".into()]),
PhysicalRow::from_values(vec![Value::Int(value)]),
))
});
let result = crate::SubqueryResult {
columns: vec!["value".into()],
rows: Box::new(rows),
};
let error = result.into_single_row().err().unwrap();
assert_eq!(error.sqlstate(), Some("21000"));
assert_eq!(count.load(std::sync::atomic::Ordering::Relaxed), 2);
}
#[test]
fn range_membership_preserves_selected_equality_in_cached_and_streamed_rows() {
let range = |text: &str| {
Value::Array(
uqa_core::ArrayValue::try_new(vec![Value::Str(text.into())])
.unwrap()
.with_element_type_oid(Some(3906)),
)
};
let first = range("[1.0,3.00)");
let equivalent = range("[1.00,3.0)");
let other = range("[10,12)");
for budget in [1, 64 * 1024] {
let services = Services::default();
let catalog = uqa_sql::expr::EngineValueCatalog(&services);
let rows = materialized(vec![first.clone(), Value::Null], budget);
let membership = rows.membership(budget, Some(&catalog)).unwrap();
for (needle, expected) in [
(&equivalent, Some(true)),
(&other, None),
(&Value::Null, None),
] {
assert_eq!(
membership.contains(needle, Some(&catalog)).unwrap(),
expected
);
assert_eq!(
rows.result()
.unwrap()
.contains_with_catalog(needle, &catalog)
.unwrap(),
expected
);
}
let scope = CteScope::new();
scope.cache_subquery(0, ScalarSubqueryCacheEntry::Materialized(rows));
let context = services.context(&scope);
let query = plan("SELECT 1");
for _ in 0..2 {
assert_eq!(
context
.subquery_contains(0, &query, &equivalent, PhysicalOuterRow::Absent, &[])
.unwrap(),
Some(true)
);
}
assert_eq!(*services.events.lock(), ["memory"]);
}
}
fn epoch_membership_cases() -> [(Option<uqa_sql::ColumnType>, uqa_core::TemporalValue, bool); 4] {
use uqa_core::TemporalValue;
use uqa_sql::ColumnType;
[
(
Some(ColumnType::Date),
TemporalValue::Date { days: 0 },
true,
),
(
Some(ColumnType::Timestamp),
TemporalValue::Timestamp {
postgres_micros: -uqa_core::POSTGRES_EPOCH_MICROS,
},
false,
),
(
Some(ColumnType::TimestampTz),
TemporalValue::TimestampTz {
postgres_micros: -uqa_core::POSTGRES_EPOCH_MICROS,
},
false,
),
(
None,
TemporalValue::Timestamp {
postgres_micros: -uqa_core::POSTGRES_EPOCH_MICROS,
},
false,
),
]
}
#[test]
fn selected_datetime_membership_keeps_one_representation_and_resolves_types_once() {
use crate::query::scope::subqueries::CachedScalarSubquery;
use crate::scalar::SubqueryNeedle;
use std::cell::Cell;
use uqa_core::TemporalValue;
use uqa_sql::ColumnType;
for budget in [1, 64 * 1024] {
for (output_type, stored, hashable) in epoch_membership_cases() {
let services = Services::default();
let scope = CteScope::new();
let schema = RowSchema::with_types(vec!["v".into()], vec![output_type]);
let mut spill = crate::SpillBuffer::new(budget);
spill
.push(crate::Batch::from_physical_rows(
schema.clone(),
vec![
PhysicalRow::from_values(vec![Value::Temporal(stored)]),
PhysicalRow::from_values(vec![Value::Null]),
],
))
.unwrap();
scope.cache_subquery(
0,
ScalarSubqueryCacheEntry::Materialized(CachedScalarSubquery {
columns: vec!["v".into()],
rows: spill.into_shared(schema).unwrap(),
}),
);
let calls = Cell::new(0);
let mut can_hash = |output: Option<&ColumnType>| {
calls.set(calls.get() + 1);
Ok(output.is_some_and(|output| {
uqa_sql::type_resolution::equality_types_share_hash_key(
&ColumnType::Date,
output,
)
}))
};
let context = services.context(&scope);
for (value, expected) in [
(Value::Temporal(TemporalValue::Date { days: 0 }), Some(true)),
(Value::Temporal(TemporalValue::Date { days: 1 }), None),
(Value::Null, None),
] {
assert_eq!(
context
.subquery_contains_selected(
0,
&plan("SELECT 1"),
SubqueryNeedle {
value: &value,
engine: Some(&services),
control: uqa_core::memory::ProductionControl::uncontrolled(),
can_hash: &mut can_hash,
},
PhysicalOuterRow::Absent,
&[]
)
.unwrap(),
expected
);
}
assert_eq!(calls.get(), 1);
assert_eq!(
matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::Membership(_))
),
hashable
);
assert_eq!(
matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::ComparedMembership(_))
),
!hashable
);
assert_eq!(
services.events.lock().as_slice(),
if hashable { &["memory"][..] } else { &[] }
);
}
}
}
#[test]
fn selected_membership_cancellation_precedes_cache_selection_and_row_reads() {
use crate::scalar::SubqueryNeedle;
use uqa_core::{
memory::{MemoryBudget, ProductionControl},
CancellationToken,
};
for cancel_original in [true, false] {
let original = CancellationToken::new();
let invoking = CancellationToken::new();
if cancel_original {
original.cancel();
} else {
invoking.cancel();
}
let budget = MemoryBudget::new(0);
let control = ProductionControl::new(&budget, &original, &invoking);
let services = Services::default();
let scope = CteScope::new();
scope.cache_subquery(
0,
ScalarSubqueryCacheEntry::Materialized(materialized(vec![Value::Null], 1)),
);
let needle = Value::Null;
let error = services
.context(&scope)
.subquery_contains_selected(
0,
&plan("SELECT 1"),
SubqueryNeedle {
value: &needle,
engine: Some(&services),
control,
can_hash: &mut |_| panic!("cancelled membership must not select its cache"),
},
PhysicalOuterRow::Absent,
&[],
)
.unwrap_err();
assert_eq!(error.sqlstate(), Some("57014"));
assert!(matches!(
scope.cached_subquery(0),
Some(ScalarSubqueryCacheEntry::Materialized(_))
));
assert!(services.events.lock().is_empty());
assert_eq!(budget.used(), 0);
}
}