use super::*;
use crate::{ast::Statement, plan::NoRegisteredAggregates};
#[test]
fn large_values_lowering_keeps_constructor_memory_bounded() {
use std::fmt::Write;
let mut sql = String::from("INSERT INTO lineitem VALUES ");
for id in 0..20_000 {
if id != 0 {
sql.push_str(", ");
}
write!(sql, "({id}, 'A', 'F', 1, 10000, 2, 365)").unwrap();
}
let source = crate::compile(&sql).unwrap().remove(0);
let budget = MemoryBudget::new(40 << 20);
let token = CancellationToken::new();
let control = ProductionControl::new(&budget, &token, &token);
let mut result = None;
let allocation = allocation_counter::measure(|| {
result = Some(UnifiedPlan::lower_borrowed_for_rewrite(
&source,
&NoRegisteredAggregates,
&control,
));
});
let output = result.unwrap().unwrap();
assert_eq!(allocation.bytes_current, budget.used() as i64);
assert!(allocation.count_current < 100_000, "{allocation:?}");
drop(output);
assert_eq!(budget.used(), 0);
}
fn verify_lowered(sql: &str) {
let source = crate::compile(sql).unwrap().remove(0);
let expected = UnifiedPlan::lower(source.clone());
let budget = MemoryBudget::new(16 << 20);
let original = CancellationToken::new();
let invoking = CancellationToken::new();
let control = ProductionControl::new(&budget, &original, &invoking);
let mut output = None;
let allocation = allocation_counter::measure(|| {
let lowered =
UnifiedPlan::lower_borrowed_for_rewrite(&source, &NoRegisteredAggregates, &control)
.unwrap();
let lowered = lowered
.map_queries_while(&control, &mut |query| Ok((query, true)))
.unwrap();
output = Some(lowered.finish(&control).unwrap());
});
let output = output.unwrap();
assert_eq!(
serde_json::to_value(&*output).unwrap(),
serde_json::to_value(&expected).unwrap(),
"{sql}"
);
assert_eq!(format!("{:?}", *output), format!("{expected:?}"), "{sql}");
assert_eq!(output.reserved_bytes(), budget.used(), "{sql}");
assert_eq!(
allocation.bytes_current,
budget.used() as i64,
"{sql}: {allocation:?}"
);
drop(output);
assert_eq!(budget.used(), 0, "{sql}");
}
#[test]
fn admitted_lowering_preserves_statements_and_scalar_query_namespaces() {
for sql in super::fixtures::STATEMENTS.iter().copied().chain([
"SELECT (SELECT 1), sum((SELECT 2)) OVER w FROM LATERAL (SELECT 3) AS t(a) WINDOW w AS (ORDER BY (SELECT 4))",
"SELECT a FROM t UNION ALL SELECT b FROM u ORDER BY 1 LIMIT (SELECT 2) OFFSET (SELECT 3)",
"WITH q AS (SELECT (SELECT 1)) SELECT * FROM q",
"WITH d AS (DELETE FROM t RETURNING (SELECT 1)) INSERT INTO u SELECT * FROM d RETURNING (SELECT 2)",
"INSERT INTO t(a[1]) VALUES ((SELECT 1)) ON CONFLICT ((a + (SELECT 2))) WHERE a > (SELECT 3) DO UPDATE SET a = (SELECT 4) WHERE a < (SELECT 5) RETURNING (SELECT 6)",
"UPDATE t SET (a, b) = (SELECT 1, 2), c[(SELECT 3)] = (SELECT 4) FROM (SELECT 5) u WHERE a = (SELECT 6) RETURNING (SELECT 7)",
"MERGE INTO t USING (SELECT 1 AS a) u ON t.a = (SELECT 2) WHEN MATCHED AND a > (SELECT 3) THEN UPDATE SET a = (SELECT 4) WHEN NOT MATCHED THEN INSERT(a) VALUES((SELECT 5)) RETURNING (SELECT 6)",
"SELECT * FROM ROWS FROM (generate_series((SELECT 1), 3), unnest(ARRAY[1, 2])) WITH ORDINALITY AS q(a, b, n)",
]) {
verify_lowered(sql);
}
}
#[test]
fn first_executable_destination_rejects_large_inputs_before_copying_them() {
let Statement::Select(mut query) = crate::compile("SELECT 'small', (SELECT 'large')")
.unwrap()
.remove(0)
else {
panic!("query")
};
let crate::ast::Expr::ScalarSubquery(inner) = &mut query.projections[1].expr else {
panic!("subquery")
};
inner.projections[0].expr = crate::ast::Expr::Literal(Value::Str("x".repeat(4 << 20)));
let source = Statement::Select(query);
let budget = MemoryBudget::new(1 << 20);
let sibling = budget.reserve(512).unwrap();
let allowance = budget.child(16 << 10);
let original = CancellationToken::new();
let invoking = CancellationToken::new();
let control = ProductionControl::new(&allowance, &original, &invoking);
let allocation = allocation_counter::measure(|| {
let error =
UnifiedPlan::lower_borrowed_for_rewrite(&source, &NoRegisteredAggregates, &control)
.unwrap_err();
assert_eq!(error.sqlstate(), Some("53200"));
});
assert!(allocation.bytes_max < 32 << 10, "{allocation:?}");
assert_eq!(allocation.bytes_current, 0);
assert_eq!(allowance.used(), 0);
assert_eq!(budget.used(), 512);
drop(sibling);
}
#[test]
fn first_executable_destination_observes_both_cancellations_and_recovers() {
let source = crate::compile("SELECT (SELECT 1)").unwrap().remove(0);
let budget = MemoryBudget::new(1 << 20);
for cancel_original in [true, false] {
let original = CancellationToken::new();
let invoking = CancellationToken::new();
if cancel_original {
original.cancel();
} else {
invoking.cancel();
}
let control = ProductionControl::new(&budget, &original, &invoking);
assert!(control.check().is_err());
let allocation = allocation_counter::measure(|| {
let error =
UnifiedPlan::lower_borrowed_for_rewrite(&source, &NoRegisteredAggregates, &control)
.unwrap_err();
assert_eq!(error.sqlstate(), Some("57014"));
});
assert_eq!(allocation.count_total, 0);
assert_eq!(budget.used(), 0);
}
let token = CancellationToken::new();
let control = ProductionControl::new(&budget, &token, &token);
let output =
UnifiedPlan::lower_borrowed_for_rewrite(&source, &NoRegisteredAggregates, &control)
.unwrap();
assert!(output.reserved_bytes() > 0);
drop(output);
assert_eq!(budget.used(), 0);
}