use super::EncodedBatchSizer;
use crate::{ExecResult, RowSchema};
#[derive(Default)]
pub(crate) struct EncodedBatchLayout {
current: Option<(RowSchema, EncodedBatchSizer)>,
}
impl EncodedBatchLayout {
pub(crate) fn for_schema(&mut self, schema: &RowSchema) -> ExecResult<EncodedBatchSizer> {
if let Some((retained, empty)) = &self.current {
if retained.shares_index(schema) {
return Ok(*empty);
}
}
let empty = EncodedBatchSizer::new(schema)?;
self.current = Some((schema.clone(), empty));
Ok(empty)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{Batch, PhysicalRow, RowLockOrigin};
use uqa_core::Value;
use uqa_sql::ColumnType;
#[test]
fn retained_batch_layout_keeps_exact_sizes_and_independent_lock_origin_state() {
let schema = RowSchema::with_types(vec!["id".into()], vec![Some(ColumnType::BigInteger)]);
let plain = PhysicalRow::from_values(vec![Value::Int(1)]);
let locked = PhysicalRow::from_values(vec![Value::Int(2)])
.with_lock_origin(RowLockOrigin::new("t", "public.t", 2));
let mut layout = EncodedBatchLayout::default();
for rows in [
vec![plain.clone(), locked.clone(), plain.clone()],
vec![plain.clone()],
vec![locked],
Vec::new(),
] {
let mut size = layout.for_schema(&schema.clone()).unwrap();
for row in &rows {
size.append(row).unwrap();
}
let expected = super::super::encoded_batch_size(&Batch::from_physical_rows(
schema.clone(),
rows.clone(),
))
.unwrap();
assert_eq!(size.bytes(), expected);
for row in rows.iter().rev() {
size.remove(row).unwrap();
}
assert_eq!(size.bytes(), layout.for_schema(&schema).unwrap().bytes());
}
}
#[test]
fn borrowed_batch_sizing_matches_owned_values_before_and_after_lock_origins() {
let schema = RowSchema::new(vec!["body".into(), "value".into()]);
let values = [Value::Str("日本λ".repeat(128)), Value::Null];
let borrowed = values.iter().collect::<Vec<_>>();
let plain = PhysicalRow::from_values(values.to_vec());
let locked = plain
.clone()
.with_lock_origin(RowLockOrigin::new("t", "public.t", 2));
for locked_first in [false, true] {
let mut rows = Vec::new();
let mut size = EncodedBatchSizer::new(&schema).unwrap();
for is_locked in [locked_first, !locked_first, false] {
if is_locked {
size.append(&locked).unwrap();
rows.push(locked.clone());
} else {
size.append_borrowed(&borrowed).unwrap();
rows.push(plain.clone());
}
assert_eq!(
size.bytes(),
super::super::encoded_batch_size(&Batch::from_physical_rows(
schema.clone(),
rows.clone()
))
.unwrap()
);
}
for row in rows.iter().rev() {
size.remove(row).unwrap();
}
assert_eq!(
size.bytes(),
EncodedBatchSizer::new(&schema).unwrap().bytes()
);
}
}
#[test]
fn retained_batch_layout_rebinds_changed_schema_names_types_and_slots() {
let plain = RowSchema::with_types(vec!["id".into()], vec![Some(ColumnType::BigInteger)]);
let qualified = RowSchema::with_relation_qualifier(&plain, "long_relation_name");
let different_type = RowSchema::with_types(
vec!["body".into()],
vec![Some(ColumnType::Varchar(Some(123)))],
);
let wider = RowSchema::with_types(
vec!["id".into(), "body".into()],
vec![Some(ColumnType::BigInteger), Some(ColumnType::Text)],
);
let mut layout = EncodedBatchLayout::default();
for schema in [&plain, &qualified, &different_type, &wider, &plain] {
let mut size = layout.for_schema(schema).unwrap();
let row = PhysicalRow::from_values(vec![Value::Null; schema.physical_width()]);
size.append(&row).unwrap();
assert_eq!(
size.bytes(),
super::super::encoded_batch_size(&Batch::from_physical_rows(
schema.clone(),
vec![row]
),)
.unwrap()
);
}
}
}