use super::*;
use uqa_sql::ast::{ColumnType, CompositeTypeReference};
use uqa_sql::schema::ScalarTypeSchema;
fn named_row_type() -> ColumnType {
ColumnType::Composite(CompositeTypeReference {
schema: "public".into(),
name: "items".into(),
oid: 20_000,
array_oid: 20_001,
relation_oid: 20_002,
})
}
#[test]
fn spill_readers_retain_named_rows_and_record_field_descriptors() {
let row_type = named_row_type();
let fields = Arc::from([Some(ColumnType::SmallInteger), Some(ColumnType::Text)]);
let schema = RowSchema::with_qualified_types(
"items",
vec!["value".into()],
vec![Some(ColumnType::Record)],
)
.with_relation_row_type("items", row_type.clone())
.unwrap()
.with_record_fields([(0, Arc::clone(&fields))]);
let values = vec![Value::Record(
vec![("n".into(), Value::Int(42)), ("s".into(), Value::Null)].into(),
)];
for budget in [0, usize::MAX] {
for mode in 0..3 {
let mut buffer = SpillBuffer::new(budget);
buffer
.push(Batch::from_physical_rows(
schema.clone(),
vec![PhysicalRow::from_values(values.clone())],
))
.unwrap();
let batches = match mode {
0 => buffer.drain_all().unwrap(),
1 => buffer
.into_shared(schema.clone())
.unwrap()
.reader()
.unwrap()
.collect::<ExecResult<Vec<_>>>()
.unwrap(),
_ => buffer
.into_shared(schema.clone())
.unwrap()
.into_reader()
.unwrap()
.collect::<ExecResult<Vec<_>>>()
.unwrap(),
};
assert_eq!(batches.len(), 1);
assert_eq!(batches[0].schema, schema);
assert_eq!(batches[0].schema.whole_row_type("items"), Some(&row_type));
assert!(Arc::ptr_eq(
batches[0].schema.record_fields(0).unwrap(),
&fields
));
assert_eq!(batches[0].rows[0].value(0), Some(&values[0]));
}
}
}
#[test]
fn empty_relation_identity_survives_spill_without_a_value_slot() {
let schema = RowSchema::new(Vec::new())
.with_relation_row_type("items", named_row_type())
.unwrap();
let row = PhysicalRow::from_values(Vec::new());
assert!(validate_decoded_schema(
Batch::from_physical_rows(RowSchema::new(Vec::new()), vec![row.clone()]),
Some(&schema),
)
.is_err());
let mut buffer = SpillBuffer::new(0);
buffer
.push(Batch::from_physical_rows(schema.clone(), vec![row]))
.unwrap();
let batches = buffer.drain_all().unwrap();
assert_eq!(batches[0].schema, schema);
assert_eq!(batches[0].rows.len(), 1);
assert_eq!(batches[0].rows[0].value(0), None);
assert!(batches[0].schema.has_qualifier("items"));
}
#[test]
fn restored_schema_rejects_different_physical_types_aliases_and_collations() {
let schema = RowSchema::with_types(vec!["value".into()], vec![Some(ColumnType::Text)])
.with_column_collations([Some(950)]);
for other in [
RowSchema::with_types(vec!["value".into()], vec![Some(ColumnType::Integer)]),
schema.clone().with_column_collations([Some(951)]),
RowSchema::with_identity_aliases(
&schema,
&[(ColumnIdentity::qualified("unexpected", "value"), 0)],
),
] {
let error = restore_decoded_schema(
Batch::from_physical_rows(other, vec![PhysicalRow::from_values(vec![Value::Null])]),
Some(&schema),
)
.unwrap_err();
assert!(error.to_string().contains("spill batch schema mismatch"));
}
}