use super::*;
use crate::PhysicalRow;
use std::sync::Arc;
fn text(value: &Value) -> &str {
let Value::Str(text) = value else {
panic!("expected text, got {value:?}");
};
text
}
#[test]
fn shared_scan_transfer_reuses_projection_without_row_routing_or_ownership_attempts() {
for width in [2, 40] {
let names = (0..width)
.map(|slot| format!("c{slot}"))
.collect::<Vec<_>>();
let schema = RowSchema::new(names.clone());
let source = Arc::new((0..width).map(|slot| Value::Int(slot as i64)).collect());
let projection: Arc<[usize]> = (0..width).rev().collect();
let rows = (0..1024)
.map(|_| PhysicalRow::from_shared_values(Arc::clone(&source), Arc::clone(&projection)))
.collect();
let batch = Batch::from_physical_rows(schema, rows);
let attempts = crate::batch::SelectedRowMaterializer::ownership_attempts();
let mut output = None;
let allocations = allocation_counter::measure(|| {
output = Some(ColumnarBatch::from_batch(&names, batch));
});
assert_eq!(
crate::batch::SelectedRowMaterializer::ownership_attempts(),
attempts
);
assert!(
allocations.count_total < width as u64 * 4 + 16,
"{allocations:?}"
);
let output = output.unwrap();
assert_eq!(output.len(), 1024);
for (slot, column) in output.columns().iter().enumerate() {
assert_eq!(
column.values,
vec![Value::Int((width - slot - 1) as i64); 1024]
);
}
assert_eq!(Arc::strong_count(&source), 1);
}
}
#[test]
fn shared_scan_transfer_releases_consumed_rows_before_the_last_donation() {
let value = "shared within the batch".repeat(1024);
let address = value.as_ptr();
let values = Arc::new(vec![Value::Str(value), Value::Int(7)]);
let projection: Arc<[usize]> = Arc::from([1, 0]);
let rows = (0..8)
.map(|_| PhysicalRow::from_shared_values(Arc::clone(&values), Arc::clone(&projection)))
.collect();
drop(values);
let names = vec!["number".into(), "text".into(), "absent".into()];
let schema = RowSchema::new(names[..2].to_vec());
let attempts = crate::batch::SelectedRowMaterializer::ownership_attempts();
let result = ColumnarBatch::from_batch(&names, Batch::from_physical_rows(schema, rows));
assert_eq!(
crate::batch::SelectedRowMaterializer::ownership_attempts() - attempts,
1
);
assert_eq!(result.columns()[0].values, vec![Value::Int(7); 8]);
assert_eq!(result.columns()[2].values, vec![Value::Null; 8]);
let texts = &result.columns()[1].values;
assert_eq!(text(&texts[7]).as_ptr(), address);
for value in &texts[..7] {
assert_eq!(value, &texts[7]);
assert_ne!(text(value).as_ptr(), address);
}
}
#[test]
fn owned_columnar_transfer_moves_selected_payloads_without_payload_allocations() {
let names = vec!["text".into(), "array".into()];
let schema = RowSchema::new(names.clone());
let mut addresses = Vec::new();
let rows = (0..32)
.map(|index| {
let string = format!("row {index} {}", "x".repeat(16 * 1024));
let nested = vec![Value::Str("nested".repeat(4096)), Value::Int(index)];
addresses.push((string.as_ptr(), nested.as_ptr()));
PhysicalRow::from_values(vec![
Value::Str(string),
Value::Array(uqa_core::ArrayValue::try_new(nested).unwrap()),
])
})
.collect();
let batch = Batch::from_physical_rows(schema, rows);
let mut result = None;
let allocated = allocation_counter::measure(|| {
result = Some(ColumnarBatch::from_batch(&names, batch));
});
assert!(allocated.bytes_total < 16 * 1024, "{allocated:?}");
let result = result.unwrap();
assert_eq!(result.len(), 32);
for (index, (string, array)) in addresses.into_iter().enumerate() {
assert_eq!(text(&result.columns()[0].values[index]).as_ptr(), string);
let Value::Array(values) = &result.columns()[1].values[index] else {
panic!("expected array");
};
assert_eq!(values.elements().as_ptr(), array);
assert_eq!(values.elements()[1], Value::Int(index as i64));
}
}
#[test]
fn owned_columnar_transfer_preserves_remapped_fragments_and_duplicate_positions() {
let source = RowSchema::new(vec!["left".into(), "unused".into(), "right".into()]);
let schema = RowSchema::select(
&source,
&[
("value".into(), "right".into()),
("left".into(), "left".into()),
("value".into(), "left".into()),
],
);
let left = "left payload".repeat(128);
let right = "right payload".repeat(128);
let left_address = left.as_ptr();
let right_address = right.as_ptr();
let row = PhysicalRow::from_values(vec![Value::Str(left), Value::Str("unused".into())])
.append_values(vec![Value::Str(right)]);
let batch = Batch::from_physical_rows(schema, vec![row]);
let result = ColumnarBatch::from_batch(
&[
"value".into(),
"left".into(),
"value".into(),
"missing".into(),
"value".into(),
],
batch,
);
let columns = result.columns();
assert_eq!(text(&columns[0].values[0]).as_ptr(), right_address);
assert_eq!(columns[1].values, columns[2].values);
assert_ne!(text(&columns[1].values[0]).as_ptr(), left_address);
assert_eq!(text(&columns[2].values[0]).as_ptr(), left_address);
assert_eq!(columns[3].values, [Value::Null]);
assert_eq!(columns[4].values, [Value::Null]);
}
#[test]
fn owned_columnar_transfer_counts_aliases_after_fragment_projection() {
let first = "selected first".repeat(128);
let second = "selected second".repeat(128);
let first_address = first.as_ptr();
let second_address = second.as_ptr();
let row = PhysicalRow::from_shared_values(
Arc::new(vec![Value::Str(first), Value::Str(second), Value::Int(42)]),
Arc::from([1, 0, 1, usize::MAX]),
);
let names = vec!["a".into(), "b".into(), "c".into(), "d".into()];
let batch = Batch::from_physical_rows(RowSchema::new(names.clone()), vec![row]);
let result = ColumnarBatch::from_batch(&names, batch);
let columns = result.columns();
assert_eq!(columns[0].values, columns[2].values);
assert_ne!(text(&columns[0].values[0]).as_ptr(), second_address);
assert_eq!(text(&columns[1].values[0]).as_ptr(), first_address);
assert_eq!(text(&columns[2].values[0]).as_ptr(), second_address);
assert_eq!(columns[3].values, [Value::Null]);
}
#[test]
fn shared_columnar_transfer_clones_only_selected_payloads() {
let stored = Arc::new(vec![
Value::Str("unused".repeat(128 * 1024)),
Value::Str("selected".into()),
]);
let row = PhysicalRow::from_shared_values(Arc::clone(&stored), Arc::from([0, 1]));
let source = RowSchema::new(vec!["unused".into(), "selected".into()]);
let schema = RowSchema::select(&source, &[("result".into(), "selected".into())]);
let batch = Batch::from_physical_rows(schema, vec![row]);
let names = vec!["result".into()];
let mut result = None;
let allocated = allocation_counter::measure(|| {
result = Some(ColumnarBatch::from_batch(&names, batch));
});
assert!(allocated.bytes_total < 4096, "{allocated:?}");
let result = result.unwrap();
assert_eq!(result.columns()[0].values, [Value::Str("selected".into())]);
assert_eq!(text(&stored[0]).len(), 6 * 128 * 1024);
assert_eq!(text(&stored[1]), "selected");
assert_ne!(
text(&result.columns()[0].values[0]).as_ptr(),
text(&stored[1]).as_ptr()
);
assert_eq!(Arc::strong_count(&stored), 1);
}
#[test]
fn owned_columnar_transfer_preserves_empty_and_zero_column_cardinality() {
for count in [0, 3] {
let rows = (0..count)
.map(|_| PhysicalRow::from_values(vec![Value::Int(42)]))
.collect();
let batch = Batch::from_physical_rows(RowSchema::new(vec!["unused".into()]), rows);
let result = ColumnarBatch::from_batch(&[], batch);
assert_eq!(result.len(), count);
assert_eq!(
result.into_positional_rows(),
vec![Vec::<Value>::new(); count]
);
let batch =
Batch::from_physical_rows(RowSchema::new(vec![]), vec![PhysicalRow::default(); count]);
let result = ColumnarBatch::from_batch(&["missing".into()], batch);
assert_eq!(result.len(), count);
assert_eq!(result.columns()[0].values, vec![Value::Null; count]);
}
}
#[test]
fn owned_columnar_transfer_matches_borrowed_across_joined_projection_layouts() {
for width in [0, 1, 8, 31] {
let stored = Arc::new(
(0..width)
.map(|i| Value::Str(format!("value {i}")))
.collect::<Vec<_>>(),
);
let projection: Arc<[usize]> = (0..width)
.rev()
.chain(0..width)
.chain([usize::MAX])
.collect();
let left = PhysicalRow::from_shared_values(Arc::clone(&stored), Arc::clone(&projection));
let right = PhysicalRow::from_shared_values(Arc::clone(&stored), Arc::clone(&projection));
let row = PhysicalRow::concat(&left, &right);
drop((left, right, stored));
let width = 2 * projection.len();
let labels = (0..width)
.map(|i| format!("label {}", i % 3))
.collect::<Vec<_>>();
let mut requested = labels.clone();
requested.reverse();
requested.push("absent".into());
let batch = Batch::from_physical_rows(RowSchema::new(labels), vec![row]);
let expected = ColumnarBatch::from_borrowed_batch(&requested, &batch);
assert_eq!(ColumnarBatch::from_batch(&requested, batch), expected);
}
}
#[test]
fn owned_columnar_transfer_moves_values_shared_only_between_input_fragments() {
for select_second in [false, true] {
let first = "first payload".repeat(1024);
let second = "second payload".repeat(1024);
let first_address = first.as_ptr();
let second_address = second.as_ptr();
let stored = Arc::new(vec![Value::Str(first), Value::Str(second)]);
let left = PhysicalRow::from_shared_values(Arc::clone(&stored), Arc::from([0]));
let right = PhysicalRow::from_shared_values(stored, Arc::from([1, 0]));
let row = PhysicalRow::concat(&left, &right);
drop((left, right));
let names = vec!["a".into(), "b".into(), "c".into()];
let batch = Batch::from_physical_rows(RowSchema::new(names.clone()), vec![row]);
let requested = if select_second {
names
} else {
vec!["a".into()]
};
let result = ColumnarBatch::from_batch(&requested, batch);
if select_second {
assert_eq!(result.columns()[0].values, result.columns()[2].values);
assert_ne!(text(&result.columns()[0].values[0]).as_ptr(), first_address);
assert_eq!(
text(&result.columns()[1].values[0]).as_ptr(),
second_address
);
assert_eq!(text(&result.columns()[2].values[0]).as_ptr(), first_address);
} else {
assert_eq!(text(&result.columns()[0].values[0]).as_ptr(), first_address);
}
}
}