use super::*;
use crate::{
ast::InternalRelationId,
schema::join_output::{compile_layout_with_control, JoinOutputSource},
};
use uqa_core::{memory::MemoryBudget, CancellationToken};
fn fixture() -> RowSchema {
let score = InternalRelationId::allocate().column(0);
let input = RowSchema::from_physical_layout(crate::schema::PhysicalLayout {
columns: ["a", "b", "a", "b", "rec"].map(String::from).into(),
identities: [("l", "a"), ("l", "b"), ("r", "a"), ("r", "b"), ("r", "rec")]
.map(|(qualifier, name)| ColumnIdentity::qualified(qualifier, name))
.into(),
types: [
ColumnType::Integer,
ColumnType::Text,
ColumnType::BigInteger,
ColumnType::Text,
ColumnType::Record,
]
.map(Some)
.into(),
slots: (0..5).map(Some).collect(),
physical_width: 6,
aliases: vec![(
ColumnIdentity::qualified("l", "hidden"),
Some(1),
Some(ColumnType::Text),
)],
internal: vec![(score, Some(5), Some(ColumnType::DoublePrecision))],
score_sources: vec![(Some("l".into()), score)],
wildcard_hidden: [3].into(),
})
.unwrap()
.with_column_collations([None, Some(950), None, Some(951), None])
.with_record_fields([(
4,
vec![Some(ColumnType::Integer), Some(ColumnType::Text)].into(),
)]);
let input = RowSchema::with_open_columns(&input, Some("l"));
input
.with_nullable_relations(InternalRelationId::allocate().column(0))
.unwrap()
}
#[test]
fn join_output_layout_retains_original_metadata_and_deduplicates_computed_positions() {
let input = fixture();
let merged = JoinOutputSource::Coalesce {
left: 0,
right: 2,
ty: ColumnType::BigInteger,
};
let columns = vec![
("a".into(), ColumnIdentity::unqualified("a"), merged.clone()),
(
"b".into(),
ColumnIdentity::qualified("l", "b"),
JoinOutputSource::Input(1),
),
(
"rec".into(),
ColumnIdentity::qualified("r", "rec"),
JoinOutputSource::Input(4),
),
];
let aliases = vec![
(
ColumnIdentity::qualified("l", "a"),
JoinOutputSource::Input(0),
),
(
ColumnIdentity::qualified("r", "a"),
JoinOutputSource::Input(2),
),
(ColumnIdentity::qualified("merged", "a"), merged),
];
let width = input.physical_width();
let expected = expected_output(&input);
let memory = MemoryBudget::new(4 << 20);
let original = CancellationToken::new();
let invoking = CancellationToken::new();
let control = ProductionControl::new(&memory, &original, &invoking);
let (schema, computed) =
compile_layout_with_control(&input, &columns, &aliases, &control).unwrap();
assert_eq!(schema, expected);
assert_eq!(computed.len(), 1);
assert_eq!(schema.physical_width(), width + 1);
assert_eq!(schema.column_collation(1), Some(950));
assert!(std::ptr::eq(
&raw const **schema.record_fields(2).unwrap(),
&raw const **input.record_fields(4).unwrap()
));
let retained = schema.clone();
let held = memory.used();
assert!(held > computed.reserved_bytes());
drop(schema);
assert_eq!(memory.used(), held);
drop(computed);
assert!(memory.used() > 0);
drop(retained);
assert_eq!(memory.used(), 0);
for token in [&original, &invoking] {
token.cancel();
assert_eq!(
compile_layout_with_control(&input, &columns, &aliases, &control)
.unwrap_err()
.sqlstate(),
Some("57014")
);
assert_eq!(memory.used(), 0);
token.reset();
}
}
#[test]
fn physical_join_alias_replaces_namespaces_and_preserves_hidden_values_and_scores() {
let input = fixture();
let names = ["id", "dup", "right_id", "dup", "record"].map(String::from);
let columns = names
.iter()
.enumerate()
.map(|(position, name)| {
(
name.clone(),
ColumnIdentity::qualified("joined", name),
position,
input.column_type(position).cloned(),
)
})
.collect::<Vec<_>>();
let expected = RowSchema::with_rebound_score_sources(
&RowSchema::remap_typed_identities_without_input_aliases(&input, &columns),
Some("joined"),
);
let memory = MemoryBudget::new(4 << 20);
let token = CancellationToken::new();
let control = ProductionControl::new(&memory, &token, &token);
let actual = crate::semantics::alias_join_physical_schema_with_control(
&input, "joined", &names, &control,
)
.unwrap();
assert_eq!(actual, expected);
assert!(!actual.has_qualifier("l"));
assert_eq!(actual.whole_row_presences().count(), 0);
assert_eq!(actual.score_sources().next().unwrap().0, Some("joined"));
drop(actual);
assert_eq!(memory.used(), 0);
let empty = RowSchema::new(vec![]);
let output =
crate::semantics::alias_join_physical_schema_with_control(&empty, "j", &[], &control)
.unwrap();
assert_eq!(output, RowSchema::with_relation_qualifier(&empty, "j"));
drop(output);
assert_eq!(memory.used(), 0);
assert_eq!(
crate::semantics::alias_join_physical_schema_with_control(
&empty,
"j",
&["extra".into()],
&control
)
.unwrap_err()
.sqlstate(),
Some("42P10")
);
assert_eq!(memory.used(), 0);
}
#[test]
fn join_output_rejects_wide_types_and_alias_names_before_allocation() {
let memory = MemoryBudget::new(32 << 10);
let token = CancellationToken::new();
let control = ProductionControl::new(&memory, &token, &token);
let input = RowSchema::with_types(vec!["value".into()], vec![Some(ColumnType::Integer)]);
let columns = vec![(
"value".into(),
ColumnIdentity::unqualified("value"),
JoinOutputSource::Cast {
input: 0,
ty: ColumnType::Array(Box::new(ColumnType::Named("x".repeat(1 << 20)))),
},
)];
let measured = allocation_counter::measure(|| {
assert_eq!(
compile_layout_with_control(&input, &columns, &[], &control)
.unwrap_err()
.sqlstate(),
Some("53200")
);
});
assert!(measured.bytes_total < 128 << 10, "{measured:?}");
assert_eq!(memory.used(), 0);
let alias = "a".repeat(1 << 20);
let measured = allocation_counter::measure(|| {
assert_eq!(
crate::semantics::alias_join_physical_schema_with_control(
&input,
&alias,
&[],
&control
)
.unwrap_err()
.sqlstate(),
Some("53200")
);
});
assert!(measured.bytes_total < 128 << 10, "{measured:?}");
assert_eq!(memory.used(), 0);
for (source, expected) in [
(
JoinOutputSource::Input(1),
"join output input position 1 is outside width 1",
),
(
JoinOutputSource::Cast {
input: 2,
ty: ColumnType::Integer,
},
"join output cast position 2 is outside width 1",
),
(
JoinOutputSource::Coalesce {
left: 0,
right: 3,
ty: ColumnType::Integer,
},
"join output coalesce positions (0, 3) are outside width 1",
),
] {
let error = compile_layout_with_control(
&input,
&[("value".into(), ColumnIdentity::unqualified("value"), source)],
&[],
&control,
)
.unwrap_err();
assert!(matches!(error, SQLError::Internal(ref message) if message == expected));
assert_eq!(memory.used(), 0);
}
}
fn expected_output(input: &RowSchema) -> RowSchema {
let width = input.physical_width();
let intermediate = RowSchema::append_hidden_typed(input, &[Some(ColumnType::BigInteger)]);
RowSchema::remap_typed_physical_identities(
&intermediate,
&[
(
"a".into(),
ColumnIdentity::unqualified("a"),
width,
Some(ColumnType::BigInteger),
),
(
"b".into(),
ColumnIdentity::qualified("l", "b"),
1,
Some(ColumnType::Text),
),
(
"rec".into(),
ColumnIdentity::qualified("r", "rec"),
4,
Some(ColumnType::Record),
),
],
&[
(
ColumnIdentity::qualified("l", "a"),
0,
Some(ColumnType::Integer),
),
(
ColumnIdentity::qualified("r", "a"),
2,
Some(ColumnType::BigInteger),
),
(
ColumnIdentity::qualified("merged", "a"),
width,
Some(ColumnType::BigInteger),
),
],
)
}
#[test]
fn controlled_selection_preserves_exact_lookup_collations_and_executor_metadata() {
let input = fixture();
let names = [
("text", "l.b"),
("record", "r.rec"),
("absent", "missing"),
("again", "l.b"),
];
let expected = RowSchema::select(
&input,
&names.map(|(output, source)| (output.into(), source.into())),
);
let memory = MemoryBudget::new(1 << 20);
let token = CancellationToken::new();
let control = ProductionControl::new(&memory, &token, &token);
let schema = RowSchema::select_with_control(&input, names, &control).unwrap();
assert_eq!(schema, expected);
assert_eq!(schema.physical_width(), input.physical_width());
assert!(memory.used() > 0);
drop(schema);
assert_eq!(memory.used(), 0);
let occupied = memory.reserve(memory.available()).unwrap();
assert_eq!(
RowSchema::select_with_control(&input, names, &control)
.unwrap_err()
.sqlstate(),
Some("53200")
);
assert_eq!(memory.used(), occupied.bytes());
}