use super::*;
use uqa_core::{memory::ProductionControl, CancellationToken};
use uqa_sql::plan::{RelationalPlan, SourcePlan};
#[rstest::rstest]
#[case::memory(Provider::Memory)]
#[case::sqlite_native(Provider::SQLiteNative)]
#[case::sqlite_kv(Provider::SQLiteKeyValue)]
#[case::redb(Provider::Redb)]
fn native_source_descriptors_admit_aliases_and_hold_the_last_schema_owner(
#[case] provider: Provider,
) {
let directory = tempfile::tempdir().unwrap();
let engine = provider.open(&directory.path().join("source-descriptors.db"));
engine.sql("CREATE TABLE source_items(id integer,v text); CREATE VIEW source_view AS SELECT id,v FROM source_items; CREATE MATERIALIZED VIEW source_mv AS SELECT id,v FROM source_items; CREATE SEQUENCE source_seq; CREATE SERVER source_server FOREIGN DATA WRAPPER memory_fdw; CREATE FOREIGN TABLE source_remote(id integer,v text) SERVER source_server", &[]).unwrap();
let resources = engine.query_retention_control().unwrap();
let memory = resources.memory();
let invoking = CancellationToken::new();
let control = ProductionControl::new(memory, resources.cancellation(), &invoking);
let scope = crate::capabilities::query_scope::new_for_statement(&engine, None).unwrap();
let baseline = memory.used();
for name in [
"source_items",
"source_view",
"source_mv",
"source_seq",
"source_remote",
"pg_catalog.pg_class",
"information_schema.columns",
] {
let UnifiedPlan::Query(mut query) = UnifiedPlan::lower(
uqa_sql::compile(&format!("SELECT * FROM {name}"))
.unwrap()
.remove(0),
) else {
panic!("query")
};
let RelationalPlan::QueryBlock(block) = &mut query.root else {
panic!("block")
};
let source = block.from.as_mut().unwrap();
let SourcePlan::Table { column_aliases, .. } = source else {
panic!("table")
};
column_aliases.push("label".repeat(1 << 18));
let occupied = memory.reserve(memory.available() - (64 << 10)).unwrap();
let mut result = None;
let allocation = allocation_counter::measure(|| {
result = Some(uqa_execution::query::binding::bind_source_plan_schema(
&engine,
source,
&[],
&scope,
None,
&control,
));
});
assert!(
allocation.bytes_total < 256 << 10,
"{provider:?} {name}: {allocation:?}"
);
assert_eq!(result.unwrap().unwrap_err().sqlstate(), Some("53200"));
assert_eq!(memory.used(), baseline + occupied.bytes());
drop(occupied);
for token in [resources.cancellation(), &invoking] {
token.cancel();
assert_eq!(
uqa_execution::query::binding::bind_source_plan_schema(
&engine,
source,
&[],
&scope,
None,
&control
)
.unwrap_err()
.sqlstate(),
Some("57014")
);
assert_eq!(memory.used(), baseline);
token.reset();
}
let schema = uqa_execution::query::binding::bind_source_plan_schema(
&engine,
source,
&[],
&scope,
None,
&control,
)
.unwrap();
assert!(memory.used() > baseline + (1 << 20));
let retained = schema.clone();
let held = memory.used();
drop(schema);
assert_eq!(memory.used(), held);
drop(retained);
assert_eq!(memory.used(), baseline);
}
drop(scope);
engine.close().unwrap();
drop(engine);
assert_eq!(memory.used(), 0);
}
#[rstest::rstest]
#[case::memory(Provider::Memory)]
#[case::sqlite_native(Provider::SQLiteNative)]
#[case::sqlite_kv(Provider::SQLiteKeyValue)]
#[case::redb(Provider::Redb)]
fn native_source_descriptors_preserve_pg18_types_collations_and_namespace_order(
#[case] provider: Provider,
) {
let directory = tempfile::tempdir().unwrap();
let engine = provider.open(&directory.path().join("source-descriptor-observations.db"));
engine.sql("CREATE SCHEMA source_schema_owner; SET search_path=source_schema_owner,pg_catalog; CREATE TABLE items(id integer,v text COLLATE \"C\"); INSERT INTO items VALUES(1,'alpha'),(2,'beta'); CREATE VIEW items_view AS SELECT id,v FROM items; CREATE MATERIALIZED VIEW items_mv AS SELECT id,v FROM items; CREATE SEQUENCE items_seq", &[]).unwrap();
for (sql, expected) in [
("SELECT pg_typeof(t)::text||':'||t::text AS result FROM items AS t(k,label) ORDER BY t.k", &["items:(1,alpha)","items:(2,beta)"][..]),
("SELECT pg_typeof(v)::text||':'||v::text AS result FROM items_view AS v(k,label) ORDER BY v.k", &["items_view:(1,alpha)","items_view:(2,beta)"][..]),
("SELECT pg_typeof(m)::text||':'||m::text AS result FROM items_mv AS m(k,label) ORDER BY m.k", &["items_mv:(1,alpha)","items_mv:(2,beta)"][..]),
("WITH c AS (SELECT id,v FROM items) SELECT c.k::text||':'||c.label||':'||pg_collation_for(c.label) AS result FROM c AS c(k,label) ORDER BY k", &["1:alpha:\"C\"","2:beta:\"C\""][..]),
("SELECT s::text||':'||pg_typeof(s.n)::text AS result FROM (SELECT 1::bigint AS id,'x'::text AS v) AS s(n,label)", &["(1,x):bigint"][..]),
("SELECT last_value::text||':'||is_called::text||':'||pg_typeof(last_value)::text AS result FROM items_seq", &["1:false:bigint"][..]),
("SELECT pg_typeof(relname)::text||':'||pg_typeof(relacl)::text AS result FROM pg_catalog.pg_class WHERE relname='items' AND relnamespace='source_schema_owner'::regnamespace", &["name:aclitem[]"][..]),
("SELECT pg_typeof(table_name)::text||':'||column_name::text AS result FROM information_schema.columns WHERE table_schema='source_schema_owner' AND table_name='items' ORDER BY ordinal_position", &["information_schema.sql_identifier:id","information_schema.sql_identifier:v"][..]),
] {
let result = engine.sql(sql, &[]).unwrap();
let actual = result.rows.iter().map(|row| match &row["result"] { Value::Str(value) => value.as_str(), value => panic!("{value:?}") }).collect::<Vec<_>>();
assert_eq!(actual, expected, "{provider:?}: {sql}");
}
for (sql, state) in [
("SELECT * FROM items AS t(a,b,c)", "42P10"),
("SELECT t.missing FROM items AS t", "42703"),
] {
assert_eq!(engine.sql(sql, &[]).unwrap_err().sqlstate(), Some(state));
assert_eq!(
engine
.sql("SELECT count(*) AS n FROM items", &[])
.unwrap()
.rows[0]["n"],
Value::Int(2)
);
}
engine.close().unwrap();
}