use super::*;
use std::sync::Arc;
use uqa_sql::{
expr::{
composites::{CompositeAttribute, CompositeTypeDescriptor},
SQLValueCatalog,
},
ColumnType, SQLError,
};
struct Catalog(Arc<CompositeTypeDescriptor>);
impl SQLValueCatalog for Catalog {
fn enum_label_uncommitted(&self, _: u32) -> bool {
false
}
fn enum_type_name(&self, _: u32) -> Result<Option<String>, SQLError> {
Ok(None)
}
fn has_enum_types(&self) -> bool {
false
}
fn enum_type_labels(
&self,
_: u32,
) -> Result<Option<Arc<uqa_sql::expr::enums::EnumTypeLabels>>, SQLError> {
Ok(None)
}
fn value_composite_type(
&self,
oid: u32,
) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError> {
Ok((oid == self.0.type_oid).then(|| self.0.clone()))
}
}
fn containers(text: &str, oid: u32) -> Vec<Value> {
let row = Value::Row(
uqa_core::RowValue::typed(
vec![Value::Str(text.into())],
vec![uqa_core::RecordFieldType {
collation_oid: None,
oid,
type_modifier: -1,
}],
)
.unwrap(),
);
vec![
row.clone(),
Value::Record(uqa_core::RecordValue::from_parts(
vec![("value".into(), Value::Str(text.into()))],
Some(16_384),
)),
Value::Array(
uqa_core::ArrayValue::try_new(vec![Value::Str(text.into())])
.unwrap()
.with_element_type_oid(Some(oid)),
),
Value::Array(uqa_core::ArrayValue::try_new(vec![row]).unwrap()),
]
}
#[test]
fn range_sql_hash_and_exact_keys_preserve_postgresql_equality_classes() {
let reference: serde_json::Value = serde_json::from_str(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../uqa-sql/src/expr/range/comparison/postgresql.json"
)))
.unwrap();
let hasher = std::collections::hash_map::RandomState::new();
for family in reference["families"].as_array().unwrap() {
let ty = ColumnType::from_sql_name(family["kind"].as_str().unwrap()).unwrap();
let oid = uqa_sql::catalog::type_metadata::pg_type_oid(&ty) as u32;
let catalog = Catalog(Arc::new(CompositeTypeDescriptor {
type_oid: 16_384,
relation_oid: 16_385,
dropped: vec![],
attributes: vec![CompositeAttribute {
name: "value".into(),
ty,
collation_oid: None,
number: 1,
}],
}));
let values = family["values"].as_array().unwrap();
for (i, left) in values.iter().enumerate() {
for (j, right) in values.iter().enumerate() {
let equal = family["comparisons"][i][j] == 0;
for (left, right) in containers(left.as_str().unwrap(), oid)
.iter()
.zip(containers(right.as_str().unwrap(), oid))
{
let encode = |value| {
encode_sql_key_with_enum_catalog(
std::iter::once(Some(value)),
Some(&catalog),
)
.unwrap()
};
assert_eq!(
encode(left) == encode(&right),
equal,
"{}: {left:?} versus {right:?}",
family["kind"]
);
if equal {
let left_locks = reservations::canonical_row_lock_keys_with_catalog(
std::slice::from_ref(left),
&catalog,
)
.unwrap();
let right_locks = reservations::canonical_row_lock_keys_with_catalog(
std::slice::from_ref(&right),
&catalog,
)
.unwrap();
assert_eq!(left_locks[0], right_locks[0]);
for (value, locks) in [(left, &left_locks), (&right, &right_locks)] {
for old in
reservations::canonical_row_lock_keys(std::slice::from_ref(value))
.unwrap()
{
assert!(
locks.contains(&old),
"a predecessor reservation alias was removed"
);
}
}
let hash = |value| {
hash_canonical_row_with_enum_catalog(
&hasher,
std::iter::once(Some(value)),
Some(&catalog),
)
.unwrap()
};
assert_eq!(hash(left), hash(&right));
}
}
}
}
}
}
#[test]
fn range_reservations_preserve_deferred_fields_and_existing_nonrange_addresses() {
let catalog = Catalog(Arc::new(CompositeTypeDescriptor {
type_oid: 16_384,
relation_oid: 16_385,
dropped: vec![],
attributes: vec![],
}));
let deferred = Value::Datum(uqa_core::DatumValue::new(23, u32::MAX, vec![]));
let invalid_vector = Value::LegacyVector(
uqa_core::LegacyVectorValue::try_from_array(
uqa_core::LegacyVectorKind::Oid,
uqa_core::ArrayValue::try_new(vec![]).unwrap(),
)
.unwrap(),
);
for value in [
deferred.clone(),
invalid_vector.clone(),
Value::Int(1),
Value::Float(0.1),
Value::Enum(
uqa_core::EnumValue::new(
16_384,
uqa_core::EnumLabelKey::initial(1).unwrap().remove(0),
)
.with_label_oid(Some(42)),
),
Value::Str("[1.0,3.00)".into()),
] {
let values = [value];
let old = reservations::canonical_row_lock_keys(&values).unwrap();
let new = reservations::canonical_row_lock_keys_with_catalog(&values, &catalog).unwrap();
assert_eq!(new.as_slice(), &old);
}
for opaque in [deferred, invalid_vector] {
let value = Value::Row(
uqa_core::RowValue::typed(
vec![Value::Str("[1.0,3.00)".into()), opaque],
vec![
uqa_core::RecordFieldType {
collation_oid: None,
oid: 3906,
type_modifier: -1,
},
uqa_core::RecordFieldType {
collation_oid: None,
oid: 23,
type_modifier: -1,
},
],
)
.unwrap(),
);
let values = [value];
let keys = reservations::canonical_row_lock_keys_with_catalog(&values, &catalog).unwrap();
assert_eq!(keys.len(), 4);
for old in reservations::canonical_row_lock_keys(&values).unwrap() {
assert!(keys.contains(&old));
}
}
}
#[test]
fn range_key_normalization_respects_the_original_allowance_and_cancellation() {
let value = containers(&format!("[1,{}.5)", "9".repeat(8_192)), 3906).remove(0);
let control = StorageReadControl::with_limit(4096);
let mut output = CatalogKeyOutput {
values: BudgetedOutput::new(&control),
enums: None,
sql_hash: true,
};
let error = encode_value(&value, &mut output).unwrap_err();
assert!(
matches!(error, ExecError::SQL(ref error) if error.sqlstate() == Some("53200")),
"{error}"
);
drop(output);
assert_eq!(control.memory().used(), 0);
control.cancellation().cancel();
let mut output = CatalogKeyOutput {
values: BudgetedOutput::new(&control),
enums: None,
sql_hash: true,
};
let error = encode_value(&value, &mut output).unwrap_err();
assert!(
matches!(error, ExecError::SQL(ref error) if error.sqlstate() == Some("57014")),
"{error}"
);
drop(output);
assert_eq!(control.memory().used(), 0);
}
#[test]
fn physical_range_fields_share_sql_hash_exact_and_spill_keys_with_admitted_values() {
let fixtures: serde_json::Value = serde_json::from_str(include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/../uqa-sql/src/expr/range/datum/fixtures.json"
)))
.unwrap();
let hasher = std::collections::hash_map::RandomState::new();
for case in fixtures["cases"]
.as_array()
.unwrap()
.iter()
.filter(|case| !case["type"].as_str().unwrap().ends_with("[]"))
{
let oid = case["oid"].as_u64().unwrap() as u32;
let uqa_sql::catalog::node_tree::Field::Node(node) =
uqa_sql::catalog::node_tree::parse(case["node"].as_str().unwrap()).unwrap()
else {
panic!("constant")
};
let uqa_sql::catalog::node_tree::Field::Datum { bytes, .. } =
node.field("constvalue").unwrap()
else {
panic!("physical datum")
};
let row = |value| {
Value::Row(
uqa_core::RowValue::typed(
vec![value],
vec![uqa_core::RecordFieldType {
collation_oid: None,
oid,
type_modifier: -1,
}],
)
.unwrap(),
)
};
let physical = row(Value::Datum(uqa_core::DatumValue::new(
oid,
0,
bytes.clone(),
)));
let admitted = row(Value::Str(case["output"].as_str().unwrap().into()));
let key =
|value| encode_sql_key_with_enum_catalog(std::iter::once(Some(value)), None).unwrap();
let hash = |value| {
hash_canonical_row_with_enum_catalog(&hasher, std::iter::once(Some(value)), None)
.unwrap()
};
assert_eq!(key(&physical), key(&admitted), "{}", case["id"]);
assert_eq!(hash(&physical), hash(&admitted), "{}", case["id"]);
for budget in [1, 64 * 1024] {
let directory = tempfile::tempdir().unwrap();
let mut seen =
crate::distinct::ExactRowSet::with_spill_directory(budget, directory.path());
assert!(seen
.insert_sql_values(std::slice::from_ref(&physical), None)
.unwrap());
assert!(!seen
.insert_sql_values(std::slice::from_ref(&admitted), None)
.unwrap());
assert_eq!(seen.has_spilled(), budget == 1);
drop(seen);
assert_eq!(std::fs::read_dir(directory.path()).unwrap().count(), 0);
}
let control = StorageReadControl::with_limit(0);
let mut output = CatalogKeyOutput {
values: BudgetedOutput::new(&control),
enums: None,
sql_hash: true,
};
assert!(encode_value(&physical, &mut output).is_err());
drop(output);
assert_eq!(control.memory().used(), 0);
}
}