use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use crate::error::{Error, Neo4jStoreError, Result};
use crate::value::{Properties, Value};
use super::dynamic::{read_u32, DynamicStore};
use super::node::NodeRecord;
use super::page::{PageLayout, RecordReader};
use super::relationship::RelationshipRecord;
use super::Neo4jStoreFormat;
const PROPERTY_RECORD_SIZE: usize = 41;
const PROPERTY_BLOCKS: usize = 4;
pub(super) fn load_node_properties(
database_directory: &Path,
format: Neo4jStoreFormat,
property_key_tokens: &BTreeMap<u32, String>,
nodes: &mut [NodeRecord],
) -> Result<PropertyCatalog> {
let mut loader = PropertyLoader::open(database_directory, format, property_key_tokens)?;
let mut catalog = PropertyCatalog::default();
for node in nodes {
let loaded = loader.load_chain(
node.next_property,
&format!("node {} property chain", node.neo4j_id),
)?;
node.properties = loaded.properties;
catalog
.dynamic_array_item_types
.extend(loaded.dynamic_array_item_types);
catalog.insert_chain(loaded.records)?;
}
Ok(catalog)
}
pub(super) fn load_relationship_properties(
database_directory: &Path,
format: Neo4jStoreFormat,
property_key_tokens: &BTreeMap<u32, String>,
relationships: &mut [RelationshipRecord],
) -> Result<PropertyCatalog> {
let mut loader = PropertyLoader::open(database_directory, format, property_key_tokens)?;
let mut catalog = PropertyCatalog::default();
for relationship in relationships {
let loaded = loader.load_chain(
relationship.next_property,
&format!("relationship {} property chain", relationship.neo4j_id),
)?;
relationship.properties = loaded.properties;
catalog
.dynamic_array_item_types
.extend(loaded.dynamic_array_item_types);
catalog.insert_chain(loaded.records)?;
}
Ok(catalog)
}
pub(super) fn load_schema_properties(
database_directory: &Path,
format: Neo4jStoreFormat,
property_key_tokens: &BTreeMap<u32, String>,
heads: &[(u64, u64)],
) -> Result<Vec<(u64, Properties)>> {
let mut loader = PropertyLoader::open(database_directory, format, property_key_tokens)?;
heads
.iter()
.map(|(rule_id, head)| {
let loaded = loader.load_chain(
Some(*head),
&format!("schema rule {rule_id} property chain"),
)?;
Ok((*rule_id, loaded.properties))
})
.collect()
}
#[derive(Clone, Debug, Default)]
pub(super) struct PropertyCatalog {
records: BTreeMap<u64, PropertyRecord>,
dynamic_array_item_types: BTreeMap<u64, u8>,
}
impl PropertyCatalog {
pub(super) fn estimated_heap_bytes(&self) -> Option<usize> {
let mut bytes = self
.dynamic_array_item_types
.len()
.checked_mul(std::mem::size_of::<(u64, u8)>() + 3 * std::mem::size_of::<usize>())?;
for record in self.records.values() {
bytes = bytes
.checked_add(std::mem::size_of::<u64>())?
.checked_add(std::mem::size_of::<PropertyRecord>())?
.checked_add(3 * std::mem::size_of::<usize>())?
.checked_add(
record
.blocks
.len()
.checked_mul(std::mem::size_of::<Block>())?,
)?;
for block in &record.blocks {
bytes = bytes
.checked_add(block.values.len().checked_mul(std::mem::size_of::<u64>())?)?;
}
}
Some(bytes)
}
pub(super) fn remove_record_for_reuse(&mut self, record_id: u64) {
self.records.remove(&record_id);
}
pub(super) fn type_name_for_key(
&self,
first_record_id: Option<u64>,
key_id: u32,
) -> Option<String> {
let record = self.record_for_key(first_record_id, key_id)?;
let block = record.blocks.iter().find(|block| block.key_id == key_id)?;
let scalar = |property_type| match property_type {
1 => Some("Boolean"),
2 => Some("Byte"),
3 => Some("Short"),
4 => Some("Char"),
5 => Some("Integer"),
6 => Some("Long"),
7 => Some("Float"),
8 => Some("Double"),
9 | 11 => Some("String"),
_ => None,
};
if let Some(name) = scalar(block.property_type) {
return Some(name.to_owned());
}
let item_type = match block.property_type {
10 => self
.dynamic_array_item_types
.get(&(block.values[0] >> 28))
.copied(),
12 => Some(((block.values[0] >> 28) & 0x0f) as u8),
_ => None,
}?;
let name = if item_type == 9 {
"String"
} else {
scalar(item_type)?
};
Some(format!("{name}Array"))
}
fn insert_chain(&mut self, records: Vec<PropertyRecord>) -> Result<()> {
for record in records {
let record_id = record.neo4j_id;
if self.records.insert(record_id, record).is_some() {
return Err(Error::Validation(format!(
"Neo4j property record {record_id} is referenced by more than one entity"
)));
}
}
Ok(())
}
pub(super) fn merge(&mut self, other: Self) -> Result<()> {
self.insert_chain(other.records.into_values().collect())?;
self.dynamic_array_item_types
.extend(other.dynamic_array_item_types);
Ok(())
}
pub(super) fn record_for_key(
&self,
first_record_id: Option<u64>,
key_id: u32,
) -> Option<&PropertyRecord> {
let mut current = first_record_id;
while let Some(record_id) = current {
let record = self.records.get(&record_id)?;
if record.blocks.iter().any(|block| block.key_id == key_id) {
return Some(record);
}
current = record.next;
}
None
}
fn record_with_capacity(
&self,
first_record_id: Option<u64>,
required_blocks: usize,
excluded_record_id: Option<u64>,
) -> Option<u64> {
let mut current = first_record_id;
while let Some(record_id) = current {
let record = self.records.get(&record_id)?;
let used_blocks = record
.blocks
.iter()
.map(|block| block.values.len())
.sum::<usize>();
if Some(record_id) != excluded_record_id
&& PROPERTY_BLOCKS.saturating_sub(used_blocks) >= required_blocks
{
return Some(record_id);
}
current = record.next;
}
None
}
pub(super) fn dynamic_reference_for_key(
&self,
first_record_id: Option<u64>,
key_id: u32,
) -> Option<DynamicPropertyReference> {
let record = self.record_for_key(first_record_id, key_id)?;
let block = record.blocks.iter().find(|block| block.key_id == key_id)?;
let kind = match block.property_type {
9 => DynamicPropertyKind::String,
10 => DynamicPropertyKind::Array,
_ => return None,
};
Some(DynamicPropertyReference {
kind,
first_record_id: block.values[0] >> 28,
})
}
pub(super) fn prepare_chain_deletion(
&self,
first_record_id: Option<u64>,
) -> std::result::Result<PropertyChainDeletion, String> {
let mut deletion = PropertyChainDeletion::default();
let mut current = first_record_id;
let mut seen = BTreeSet::new();
while let Some(record_id) = current {
if !seen.insert(record_id) {
return Err(format!("property chain cycle at record {record_id}"));
}
let record = self.records.get(&record_id).ok_or_else(|| {
format!("property record {record_id} disappeared from the catalog")
})?;
for block in &record.blocks {
match block.property_type {
9 => deletion.dynamic_strings.push(block.values[0] >> 28),
10 => deletion.dynamic_arrays.push(block.values[0] >> 28),
_ => {}
}
}
deletion.property_records.push((record_id, [0_u8; 41]));
current = record.next;
}
Ok(deletion)
}
}
#[derive(Debug, Default, PartialEq, Eq)]
pub(super) struct PropertyChainDeletion {
pub(super) property_records: Vec<(u64, [u8; 41])>,
pub(super) dynamic_strings: Vec<u64>,
pub(super) dynamic_arrays: Vec<u64>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum DynamicPropertyKind {
String,
Array,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) struct DynamicPropertyReference {
pub(super) kind: DynamicPropertyKind,
pub(super) first_record_id: u64,
}
pub(super) fn prepare_fixed_size_update(
catalog: &PropertyCatalog,
first_record_id: Option<u64>,
key_id: u32,
value: &Value,
) -> std::result::Result<(u64, [u8; PROPERTY_RECORD_SIZE]), String> {
let record = catalog
.record_for_key(first_record_id, key_id)
.ok_or_else(|| format!("property key token ID {key_id} is not present in the chain"))?;
let mut updated = record.clone();
replace_fixed_size_scalar(&mut updated, key_id, value)?;
let bytes = encode_record(&updated)?;
Ok((updated.neo4j_id, bytes))
}
pub(super) fn apply_fixed_size_update(
catalog: &mut PropertyCatalog,
first_record_id: Option<u64>,
key_id: u32,
value: &Value,
allocation_id: Option<u64>,
dynamic_string_id: Option<u64>,
dynamic_array_id: Option<u64>,
) -> std::result::Result<PropertyMutation, String> {
let encoded = match (value, dynamic_string_id, dynamic_array_id) {
(Value::String(_), Some(record_id), None) => {
encode_dynamic_reference(key_id, 9, record_id)?
}
(Value::List(_), None, Some(record_id)) => encode_dynamic_reference(key_id, 10, record_id)?,
_ => encode_inline_value(key_id, value)?,
};
let existing_record_id = catalog
.record_for_key(first_record_id, key_id)
.map(|record| record.neo4j_id);
let block = Block {
key_id,
property_type: ((encoded[0] >> 24) & 0x0f) as u8,
values: encoded,
};
if let (Value::List(values), Some(first_dynamic_id)) = (value, dynamic_array_id) {
if let Some(item_type) = array_item_type_for_values(values) {
catalog
.dynamic_array_item_types
.insert(first_dynamic_id, item_type);
}
}
if let Some(source_id) = existing_record_id {
let source = catalog
.records
.get(&source_id)
.ok_or_else(|| format!("property record {source_id} disappeared from the catalog"))?;
let block_index = source
.blocks
.iter()
.position(|candidate| candidate.key_id == key_id)
.ok_or_else(|| format!("property key token ID {key_id} disappeared from the record"))?;
if source.blocks[block_index].values == block.values {
return Ok(PropertyMutation {
records: vec![(source_id, encode_record(source)?)],
new_head: None,
});
}
let used_blocks = source
.blocks
.iter()
.map(|candidate| candidate.values.len())
.sum::<usize>();
let required_blocks =
used_blocks - source.blocks[block_index].values.len() + block.values.len();
if required_blocks <= PROPERTY_BLOCKS {
let mut updated = source.clone();
updated.blocks[block_index] = block;
let bytes = encode_record(&updated)?;
catalog.records.insert(source_id, updated);
return Ok(PropertyMutation {
records: vec![(source_id, bytes)],
new_head: None,
});
}
let mut updated_source = source.clone();
updated_source.blocks.remove(block_index);
if let Some(target_id) =
catalog.record_with_capacity(first_record_id, block.values.len(), Some(source_id))
{
let mut target = catalog.records[&target_id].clone();
target.blocks.push(block);
let source_bytes = encode_record(&updated_source)?;
let target_bytes = encode_record(&target)?;
catalog.records.insert(source_id, updated_source);
catalog.records.insert(target_id, target);
return Ok(PropertyMutation {
records: vec![(source_id, source_bytes), (target_id, target_bytes)],
new_head: None,
});
}
return allocate_new_head(
catalog,
first_record_id,
allocation_id,
block,
Some(updated_source),
);
}
if let Some(record_id) = catalog.record_with_capacity(first_record_id, block.values.len(), None)
{
let mut updated = catalog.records[&record_id].clone();
updated.blocks.push(block);
let bytes = encode_record(&updated)?;
catalog.records.insert(record_id, updated);
return Ok(PropertyMutation {
records: vec![(record_id, bytes)],
new_head: None,
});
}
allocate_new_head(catalog, first_record_id, allocation_id, block, None)
}
fn allocate_new_head(
catalog: &mut PropertyCatalog,
first_record_id: Option<u64>,
allocation_id: Option<u64>,
block: Block,
changed_record: Option<PropertyRecord>,
) -> std::result::Result<PropertyMutation, String> {
let record_id = allocation_id.ok_or_else(|| {
format!(
"writing property key token ID {} requires allocating a property record",
block.key_id
)
})?;
if catalog.records.contains_key(&record_id) {
return Err(format!(
"allocated property record {record_id} is already in use"
));
}
let new_record = PropertyRecord {
neo4j_id: record_id,
previous: None,
next: first_record_id,
blocks: vec![block],
};
let mut changed = BTreeMap::new();
if let Some(record) = changed_record {
changed.insert(record.neo4j_id, record);
}
if let Some(old_head_id) = first_record_id {
let old_head = if let Some(old_head) = changed.get_mut(&old_head_id) {
old_head
} else {
let old_head = catalog.records.get(&old_head_id).ok_or_else(|| {
format!("property chain head {old_head_id} disappeared from the catalog")
})?;
changed
.entry(old_head_id)
.or_insert_with(|| old_head.clone())
};
old_head.previous = Some(record_id);
}
let mut records = Vec::with_capacity(changed.len() + 1);
for record in changed.values() {
records.push((record.neo4j_id, encode_record(record)?));
}
records.push((record_id, encode_record(&new_record)?));
for (changed_id, record) in changed {
catalog.records.insert(changed_id, record);
}
catalog.records.insert(record_id, new_record);
Ok(PropertyMutation {
records,
new_head: Some(record_id),
})
}
#[derive(Debug)]
pub(super) struct PropertyMutation {
pub(super) records: Vec<(u64, [u8; PROPERTY_RECORD_SIZE])>,
pub(super) new_head: Option<u64>,
}
pub(super) fn apply_removal(
catalog: &mut PropertyCatalog,
first_record_id: Option<u64>,
key_id: u32,
) -> std::result::Result<Option<PropertyRemoval>, String> {
let Some(record_id) = catalog
.record_for_key(first_record_id, key_id)
.map(|record| record.neo4j_id)
else {
return Ok(None);
};
let record = catalog
.records
.get(&record_id)
.ok_or_else(|| format!("property record {record_id} disappeared from the catalog"))?;
let block_index = record
.blocks
.iter()
.position(|block| block.key_id == key_id)
.ok_or_else(|| format!("property key token ID {key_id} disappeared from the record"))?;
let dynamic = match record.blocks[block_index].property_type {
9 => Some(DynamicPropertyReference {
kind: DynamicPropertyKind::String,
first_record_id: record.blocks[block_index].values[0] >> 28,
}),
10 => Some(DynamicPropertyReference {
kind: DynamicPropertyKind::Array,
first_record_id: record.blocks[block_index].values[0] >> 28,
}),
_ => None,
};
if record.blocks.len() == 1 {
let is_head = first_record_id == Some(record_id);
let previous = record.previous;
let next = record.next;
if is_head && previous.is_some() {
return Err(format!(
"property chain head {record_id} has a previous record"
));
}
if !is_head && previous.is_none() {
return Err(format!(
"non-head property record {record_id} has no previous record"
));
}
let mut changed = Vec::with_capacity(2);
if let Some(previous_id) = previous {
let mut previous_record =
catalog.records.get(&previous_id).cloned().ok_or_else(|| {
format!("previous property record {previous_id} disappeared from the catalog")
})?;
if previous_record.next != Some(record_id) {
return Err(format!(
"previous property record {previous_id} does not reference {record_id}"
));
}
previous_record.next = next;
changed.push(previous_record);
}
if let Some(next_id) = next {
let mut next_record = catalog.records.get(&next_id).cloned().ok_or_else(|| {
format!("next property record {next_id} disappeared from the catalog")
})?;
if next_record.previous != Some(record_id) {
return Err(format!(
"next property record {next_id} does not reference {record_id}"
));
}
next_record.previous = previous;
changed.push(next_record);
}
let mut records = changed
.iter()
.map(|record| Ok((record.neo4j_id, encode_record(record)?)))
.collect::<std::result::Result<Vec<_>, String>>()?;
records.push((record_id, [0_u8; PROPERTY_RECORD_SIZE]));
for record in changed {
catalog.records.insert(record.neo4j_id, record);
}
catalog.records.remove(&record_id);
return Ok(Some(PropertyRemoval {
records,
owner_head: is_head.then_some(next),
freed_record_id: Some(record_id),
dynamic,
}));
}
let mut updated = record.clone();
updated.blocks.remove(block_index);
let bytes = encode_record(&updated)?;
catalog.records.insert(record_id, updated);
Ok(Some(PropertyRemoval {
records: vec![(record_id, bytes)],
owner_head: None,
freed_record_id: None,
dynamic,
}))
}
#[derive(Debug, PartialEq, Eq)]
pub(super) struct PropertyRemoval {
pub(super) records: Vec<(u64, [u8; PROPERTY_RECORD_SIZE])>,
pub(super) owner_head: Option<Option<u64>>,
pub(super) freed_record_id: Option<u64>,
pub(super) dynamic: Option<DynamicPropertyReference>,
}
struct LoadedPropertyChain {
properties: Properties,
records: Vec<PropertyRecord>,
dynamic_array_item_types: BTreeMap<u64, u8>,
}
struct PropertyLoader<'a> {
reader: RecordReader,
keys: &'a BTreeMap<u32, String>,
strings: DynamicStore,
arrays: DynamicStore,
}
impl<'a> PropertyLoader<'a> {
fn open(
database_directory: &Path,
format: Neo4jStoreFormat,
keys: &'a BTreeMap<u32, String>,
) -> Result<Self> {
let path = database_directory.join("neostore.propertystore.db");
let layout = PageLayout::new(&path, format, PROPERTY_RECORD_SIZE)?;
Ok(Self {
reader: RecordReader::open(&path, "property", layout)?,
keys,
strings: DynamicStore::open(
&database_directory.join("neostore.propertystore.db.strings"),
format,
"dynamic string property",
)?,
arrays: DynamicStore::open(
&database_directory.join("neostore.propertystore.db.arrays"),
format,
"dynamic array property",
)?,
})
}
fn load_chain(&mut self, first_id: Option<u64>, context: &str) -> Result<LoadedPropertyChain> {
let mut properties = Properties::new();
let mut records = Vec::new();
let mut dynamic_array_item_types = BTreeMap::new();
let mut seen_records = BTreeSet::new();
let mut current = first_id;
let mut expected_previous = None;
while let Some(record_id) = current {
if !seen_records.insert(record_id) {
return Err(self.invalid(
record_id,
context,
format!("property chain cycle at record {record_id}"),
));
}
if record_id >= self.reader.record_count() {
return Err(self.invalid(
record_id,
context,
"property chain points outside store",
));
}
let bytes = self.reader.read(record_id)?;
let record = decode_record(&bytes, record_id, &self.reader, context)?;
if record.previous != expected_previous {
return Err(self.invalid(
record_id,
context,
format!(
"previous property reference {:?} does not match expected {:?}",
record.previous, expected_previous
),
));
}
for block in &record.blocks {
let key = self.keys.get(&block.key_id).ok_or_else(|| {
self.invalid(
record_id,
context,
format!("unknown property key token ID {}", block.key_id),
)
})?;
if properties.contains_key(key) {
return Err(self.invalid(
record_id,
context,
format!("duplicate property key '{key}'"),
));
}
let value = self.decode_value(record_id, context, block)?;
if block.property_type == 10 {
let first_dynamic_id = block.values[0] >> 28;
let chain_context = format!(
"{context}, property record {record_id}, key {} dynamic array chain",
block.key_id
);
let bytes = self.arrays.read_chain(first_dynamic_id, &chain_context)?;
let item_type = *bytes.first().ok_or_else(|| {
self.arrays.invalid(
first_dynamic_id,
&chain_context,
"dynamic array is empty",
)
})?;
dynamic_array_item_types.insert(first_dynamic_id, item_type);
}
properties.insert(key.clone(), value);
}
expected_previous = Some(record_id);
current = record.next;
records.push(record);
}
Ok(LoadedPropertyChain {
properties,
records,
dynamic_array_item_types,
})
}
fn decode_value(&mut self, record_id: u64, context: &str, block: &Block) -> Result<Value> {
let first = block.values[0];
let raw = first >> 28;
match block.property_type {
1 => Ok(Value::Boolean(raw & 1 != 0)),
2 => Ok(Value::Integer((raw as u8 as i8) as i64)),
3 => Ok(Value::Integer((raw as u16 as i16) as i64)),
4 => {
let value = raw as u16 as u32;
let character = char::from_u32(value).ok_or_else(|| {
self.invalid(
record_id,
context,
format!("invalid char value 0x{value:04x}"),
)
})?;
Ok(Value::String(character.to_string()))
}
5 => Ok(Value::Integer((raw as u32 as i32) as i64)),
6 => {
let value = if first & 0x1000_0000 != 0 {
(raw >> 1) as i64
} else {
block.values[1] as i64
};
Ok(Value::Integer(value))
}
7 => Ok(Value::Float(f32::from_bits(raw as u32) as f64)),
8 => Ok(Value::Float(f64::from_bits(block.values[1]))),
9 => {
let first_dynamic_id = raw;
let chain_context = format!(
"{context}, property record {record_id}, key {} dynamic string chain",
block.key_id
);
let bytes = self.strings.read_chain(first_dynamic_id, &chain_context)?;
let value = String::from_utf8(bytes).map_err(|error| {
self.strings.invalid(
first_dynamic_id,
&chain_context,
format!("string property is not valid UTF-8: {error}"),
)
})?;
Ok(Value::String(value))
}
10 => {
let first_dynamic_id = raw;
let chain_context = format!(
"{context}, property record {record_id}, key {} dynamic array chain",
block.key_id
);
let bytes = self.arrays.read_chain(first_dynamic_id, &chain_context)?;
decode_dynamic_array(&bytes).map_err(|message| {
self.arrays
.invalid(first_dynamic_id, &chain_context, message)
})
}
11 => decode_short_string(&block.values)
.map(Value::String)
.map_err(|message| self.invalid(record_id, context, message)),
12 => decode_short_array(&block.values)
.map_err(|message| self.invalid(record_id, context, message)),
13 => Err(self.unsupported(record_id, context, "point property")),
14 => Err(self.unsupported(record_id, context, "temporal or duration property")),
property_type => Err(self.invalid(
record_id,
context,
format!("unknown property type {property_type}"),
)),
}
}
fn unsupported(&self, record_id: u64, context: &str, feature: &str) -> crate::Error {
Neo4jStoreError::InvalidRecord {
path: PathBuf::from(self.reader.path()),
record_type: "property".to_owned(),
record_id,
offset: self.reader.offset(record_id).unwrap_or(u64::MAX),
context: context.to_owned(),
message: format!("unsupported {feature}"),
}
.into()
}
fn invalid(&self, record_id: u64, context: &str, message: impl Into<String>) -> crate::Error {
invalid_property(&self.reader, record_id, context, message)
}
}
#[derive(Clone, Debug, PartialEq)]
pub(super) struct PropertyRecord {
neo4j_id: u64,
previous: Option<u64>,
next: Option<u64>,
blocks: Vec<Block>,
}
#[derive(Clone, Debug, PartialEq)]
struct Block {
key_id: u32,
property_type: u8,
values: Vec<u64>,
}
#[allow(dead_code)]
pub(super) fn replace_fixed_size_scalar(
record: &mut PropertyRecord,
key_id: u32,
value: &Value,
) -> std::result::Result<(), String> {
let encoded = encode_inline_value(key_id, value)?;
replace_encoded_value(record, key_id, encoded)
}
fn replace_encoded_value(
record: &mut PropertyRecord,
key_id: u32,
encoded: Vec<u64>,
) -> std::result::Result<(), String> {
let block_index = record
.blocks
.iter()
.position(|block| block.key_id == key_id)
.ok_or_else(|| format!("property key token ID {key_id} is not present in the record"))?;
let block = &record.blocks[block_index];
if matches!(block.property_type, 9 | 10) {
if block.values == encoded {
return Ok(());
}
return Err("replacing a dynamic property requires dynamic record reclamation".to_owned());
}
let used_blocks = record
.blocks
.iter()
.map(|block| block.values.len())
.sum::<usize>();
let required_blocks = used_blocks - block.values.len() + encoded.len();
if required_blocks > PROPERTY_BLOCKS {
return Err(format!(
"property update needs {required_blocks} blocks but the record holds only {PROPERTY_BLOCKS}"
));
}
let block = &mut record.blocks[block_index];
block.property_type = ((encoded[0] >> 24) & 0x0f) as u8;
block.values = encoded;
Ok(())
}
fn encode_dynamic_reference(
key_id: u32,
property_type: u8,
record_id: u64,
) -> std::result::Result<Vec<u64>, String> {
if key_id > 0x00ff_ffff {
return Err(format!("property key token ID {key_id} exceeds 24 bits"));
}
if record_id > 0x0f_ffff_ffff {
return Err(format!(
"dynamic record reference {record_id} exceeds 36 bits"
));
}
Ok(vec![
key_id as u64 | ((property_type as u64) << 24) | (record_id << 28),
])
}
#[allow(dead_code)]
pub(super) fn encode_record(record: &PropertyRecord) -> std::result::Result<[u8; 41], String> {
let (previous_low, previous_modifier) = encode_reference(record.previous)?;
let (next_low, next_modifier) = encode_reference(record.next)?;
let mut payload = [0_u64; PROPERTY_BLOCKS];
let mut payload_offset = 0_usize;
for block in &record.blocks {
let first = *block
.values
.first()
.ok_or_else(|| "property block is empty".to_owned())?;
let encoded_key = (first & 0x00ff_ffff) as u32;
let encoded_type = ((first >> 24) & 0x0f) as u8;
if encoded_key != block.key_id || encoded_type != block.property_type {
return Err("property block header does not match its decoded key and type".to_owned());
}
if block_count(first, encoded_type) != Some(block.values.len()) {
return Err(format!(
"property block encoding does not match its {}-block payload",
block.values.len()
));
}
let end = payload_offset
.checked_add(block.values.len())
.ok_or_else(|| "property block offset overflow".to_owned())?;
if end > PROPERTY_BLOCKS {
return Err(format!(
"property record needs {end} blocks but only {PROPERTY_BLOCKS} are available"
));
}
if block.values[0] == 0 {
return Err("property block is empty or not in use".to_owned());
}
payload[payload_offset..end].copy_from_slice(&block.values);
payload_offset = end;
}
if payload_offset == 0 {
return Err("property record has no in-use blocks".to_owned());
}
let mut bytes = [0_u8; PROPERTY_RECORD_SIZE];
bytes[0] = (previous_modifier << 4) | next_modifier;
bytes[1..5].copy_from_slice(&previous_low.to_be_bytes());
bytes[5..9].copy_from_slice(&next_low.to_be_bytes());
for (index, block) in payload.iter().enumerate() {
let offset = 9 + index * 8;
bytes[offset..offset + 8].copy_from_slice(&block.to_be_bytes());
}
Ok(bytes)
}
#[allow(dead_code)]
fn encode_inline_value(key_id: u32, value: &Value) -> std::result::Result<Vec<u64>, String> {
if key_id > 0x00ff_ffff {
return Err(format!("property key token ID {key_id} exceeds 24 bits"));
}
let key = key_id as u64;
match value {
Value::Boolean(value) => Ok(vec![key | (1_u64 << 24) | ((*value as u64) << 28)]),
Value::Integer(value) if (0..(1_i64 << 35)).contains(value) => Ok(vec![
key | (6_u64 << 24) | (1_u64 << 28) | ((*value as u64) << 29),
]),
Value::Integer(value) => Ok(vec![key | (6_u64 << 24), *value as u64]),
Value::Float(value) => Ok(vec![key | (8_u64 << 24), value.to_bits()]),
Value::String(value) => encode_short_utf8_string(key_id, value),
Value::List(values) => encode_short_array(key_id, values),
_ => Err("inline property writes support only boolean, integer, float, short UTF-8 string, and short numeric/boolean array values".to_owned()),
}
}
fn encode_short_utf8_string(key_id: u32, value: &str) -> std::result::Result<Vec<u64>, String> {
let bytes = value.as_bytes();
let block_count = (39 + bytes.len() * 8).div_ceil(64);
if bytes.len() > 27 || block_count > PROPERTY_BLOCKS {
return Err(format!(
"short UTF-8 string needs {} bytes; inline storage supports at most 27",
bytes.len()
));
}
let mut blocks = vec![0_u64; block_count];
write_block_bits(&mut blocks, 0, 24, key_id as u64);
write_block_bits(&mut blocks, 24, 4, 11);
write_block_bits(&mut blocks, 28, 5, 0);
write_block_bits(&mut blocks, 33, 6, bytes.len() as u64);
for (index, byte) in bytes.iter().enumerate() {
write_block_bits(&mut blocks, 39 + index * 8, 8, *byte as u64);
}
Ok(blocks)
}
fn encode_short_array(key_id: u32, values: &[Value]) -> std::result::Result<Vec<u64>, String> {
let first = values
.first()
.ok_or_else(|| "empty arrays require component type metadata".to_owned())?;
let item_type = match first {
Value::Boolean(_) => 1_u64,
Value::Integer(_) => 6_u64,
Value::Float(_) => 8_u64,
_ => {
return Err(
"short arrays support only homogeneous boolean, integer, or float values"
.to_owned(),
)
}
};
if values.len() > 63 {
return Err("short array length exceeds 63 items".to_owned());
}
let mut raw_values = Vec::with_capacity(values.len());
for value in values {
let raw = match (item_type, value) {
(1, Value::Boolean(value)) => *value as u64,
(6, Value::Integer(value)) => *value as u64,
(8, Value::Float(value)) => value.to_bits(),
_ => return Err("short array values must have one homogeneous type".to_owned()),
};
raw_values.push(raw);
}
let bits_per_value = if item_type == 1 {
1
} else {
raw_values
.iter()
.map(|value| (64 - value.leading_zeros()).max(1) as usize)
.max()
.unwrap_or(1)
};
let encoded_bits = if bits_per_value == 64 {
0
} else {
bits_per_value as u64
};
let block_count = (44 + values.len() * bits_per_value).div_ceil(64);
if block_count > PROPERTY_BLOCKS {
return Err(format!(
"short array needs {block_count} property blocks but only {PROPERTY_BLOCKS} are available"
));
}
let mut blocks = vec![0_u64; block_count];
write_block_bits(&mut blocks, 0, 24, key_id as u64);
write_block_bits(&mut blocks, 24, 4, 12);
write_block_bits(&mut blocks, 28, 4, item_type);
write_block_bits(&mut blocks, 32, 6, values.len() as u64);
write_block_bits(&mut blocks, 38, 6, encoded_bits);
for (index, raw) in raw_values.into_iter().enumerate() {
write_block_bits(
&mut blocks,
44 + index * bits_per_value,
bits_per_value,
raw,
);
}
Ok(blocks)
}
pub(super) fn encode_dynamic_array_payload(
value: &Value,
) -> std::result::Result<Option<Vec<u8>>, String> {
let Value::List(values) = value else {
return Ok(None);
};
let first = values
.first()
.ok_or_else(|| "empty arrays require component type metadata".to_owned())?;
let item_type =
match first {
Value::Boolean(_) => 1_u8,
Value::Integer(_) => 6_u8,
Value::Float(_) => 8_u8,
Value::String(_) => 9_u8,
_ => return Err(
"dynamic arrays support only homogeneous boolean, integer, float, or string values"
.to_owned(),
),
};
let homogeneous = values.iter().all(|value| {
matches!(
(item_type, value),
(1, Value::Boolean(_))
| (6, Value::Integer(_))
| (8, Value::Float(_))
| (9, Value::String(_))
)
});
if !homogeneous {
return Err("dynamic array values must have one homogeneous type".to_owned());
}
if item_type != 9 && encode_short_array(0, values).is_ok() {
return Ok(None);
}
if item_type == 9 {
let mut bytes = Vec::new();
bytes.push(9);
let count = u32::try_from(values.len())
.map_err(|_| "dynamic string array has too many items".to_owned())?;
bytes.extend_from_slice(&count.to_be_bytes());
for value in values {
let Value::String(value) = value else {
unreachable!("homogeneous type checked above");
};
let length = u32::try_from(value.len())
.map_err(|_| "dynamic string array item is too large".to_owned())?;
bytes.extend_from_slice(&length.to_be_bytes());
bytes.extend_from_slice(value.as_bytes());
}
return Ok(Some(bytes));
}
let raw_values = values
.iter()
.map(|value| match value {
Value::Boolean(value) => *value as u64,
Value::Integer(value) => *value as u64,
Value::Float(value) => value.to_bits(),
_ => unreachable!("homogeneous type checked above"),
})
.collect::<Vec<_>>();
let bits_per_value = match item_type {
1 => 1,
8 => 64,
_ => raw_values
.iter()
.map(|value| (64 - value.leading_zeros()).max(1) as usize)
.max()
.unwrap_or(1),
};
let total_bits = bits_per_value
.checked_mul(raw_values.len())
.ok_or_else(|| "dynamic array bit length overflow".to_owned())?;
let bits_in_last_byte = match total_bits % 8 {
0 => 8,
bits => bits,
};
let mut bytes = vec![0_u8; 3 + total_bits.div_ceil(8)];
bytes[0] = item_type;
bytes[1] = bits_in_last_byte as u8;
bytes[2] = bits_per_value as u8;
for (index, raw) in raw_values.into_iter().enumerate() {
for bit in 0..bits_per_value {
bytes[3 + (index * bits_per_value + bit) / 8] |=
(((raw >> bit) & 1) as u8) << ((index * bits_per_value + bit) % 8);
}
}
Ok(Some(bytes))
}
#[allow(dead_code)]
fn encode_reference(reference: Option<u64>) -> std::result::Result<(u32, u8), String> {
match reference {
None => Ok((u32::MAX, 0)),
Some(reference) if reference <= 0x0f_ffff_ffff => {
Ok((reference as u32, (reference >> 32) as u8))
}
Some(reference) => Err(format!(
"property record reference {reference} exceeds 36 bits"
)),
}
}
fn decode_record(
bytes: &[u8],
record_id: u64,
reader: &RecordReader,
context: &str,
) -> Result<PropertyRecord> {
let modifiers = bytes[0];
let previous = decode_reference(read_u32(&bytes[1..5]), ((modifiers & 0xf0) as u64) << 28);
let next = decode_reference(read_u32(&bytes[5..9]), ((modifiers & 0x0f) as u64) << 32);
let mut payload = [0_u64; PROPERTY_BLOCKS];
for (index, value) in payload.iter_mut().enumerate() {
let offset = 9 + index * 8;
*value = u64::from_be_bytes(bytes[offset..offset + 8].try_into().map_err(|_| {
invalid_property(reader, record_id, context, "truncated property block")
})?);
}
if payload[0] == 0 {
return Err(invalid_property(
reader,
record_id,
context,
"referenced property record is not in use",
));
}
let mut blocks = Vec::new();
let mut index = 0;
while index < PROPERTY_BLOCKS && payload[index] != 0 {
let first = payload[index];
let property_type = ((first >> 24) & 0x0f) as u8;
let count = block_count(first, property_type).ok_or_else(|| {
invalid_property(
reader,
record_id,
context,
format!("invalid property type or encoding {property_type}"),
)
})?;
if index + count > PROPERTY_BLOCKS {
return Err(invalid_property(
reader,
record_id,
context,
format!(
"property block requires {count} slots but only {} remain",
PROPERTY_BLOCKS - index
),
));
}
blocks.push(Block {
key_id: (first & 0x00ff_ffff) as u32,
property_type,
values: payload[index..index + count].to_vec(),
});
index += count;
}
Ok(PropertyRecord {
neo4j_id: record_id,
previous,
next,
blocks,
})
}
fn block_count(first: u64, property_type: u8) -> Option<usize> {
match property_type {
1..=5 | 7 | 9 | 10 => Some(1),
6 => Some(if first & 0x1000_0000 != 0 { 1 } else { 2 }),
8 => Some(2),
11 => short_string_block_count(first),
12 => short_array_block_count(first),
13 | 14 => Some(1),
_ => None,
}
}
fn short_string_block_count(first: u64) -> Option<usize> {
let encoding = ((first >> 28) & 0x1f) as usize;
let length = ((first >> 33) & 0x3f) as usize;
let bits = match encoding {
0 | 10 => 8,
1 | 2 | 11 | 12 => 4,
3..=5 => 5,
6..=8 => 6,
9 => 7,
_ => return None,
};
Some((39 + length * bits).div_ceil(64))
}
fn short_array_block_count(first: u64) -> Option<usize> {
let length = ((first >> 32) & 0x3f) as usize;
let encoded_bits = ((first >> 38) & 0x3f) as usize;
let bits = if encoded_bits == 0 { 64 } else { encoded_bits };
let count = (44 + length.checked_mul(bits)?).div_ceil(64);
(count > 0).then_some(count)
}
fn decode_short_string(blocks: &[u64]) -> std::result::Result<String, String> {
let first = blocks[0];
let encoding = ((first >> 28) & 0x1f) as u8;
let length = ((first >> 33) & 0x3f) as usize;
let bits_per_character = short_string_bits(encoding)
.ok_or_else(|| format!("unknown short string encoding {encoding}"))?;
let mut raw = Vec::with_capacity(length);
for index in 0..length {
raw.push(
read_block_bits(blocks, 39 + index * bits_per_character, bits_per_character) as u8,
);
}
match encoding {
0 => String::from_utf8(raw)
.map_err(|error| format!("short UTF-8 string is invalid: {error}")),
10 => Ok(raw.into_iter().map(char::from).collect()),
_ => raw
.into_iter()
.map(|code| decode_short_character(encoding, code))
.collect(),
}
}
fn short_string_bits(encoding: u8) -> Option<usize> {
match encoding {
0 | 10 => Some(8),
1 | 2 | 11 | 12 => Some(4),
3..=5 => Some(5),
6..=8 => Some(6),
9 => Some(7),
_ => None,
}
}
fn decode_short_character(encoding: u8, code: u8) -> std::result::Result<char, String> {
const PUNCTUATION: &[u8] = b" _.-:/ .-+,'@|;*?&%#()$<>=";
let punctuation = |index: usize| {
PUNCTUATION
.get(index)
.copied()
.map(char::from)
.ok_or_else(|| {
format!("invalid punctuation code {index} for short string encoding {encoding}")
})
};
let ascii = match encoding {
1 => {
if code < 10 {
char::from(b'0' + code)
} else {
return punctuation(code as usize - 4);
}
}
2 => match code {
0..=9 => char::from(b'0' + code),
10 => ' ',
11 => '-',
12 => ':',
13 => '/',
14 => '+',
15 => ',',
_ => return Err(format!("invalid DATE code {code}")),
},
3 | 4 => {
if code == 0 {
' '
} else if code <= 26 {
char::from(if encoding == 3 { b'A' } else { b'a' } + code - 1)
} else {
return punctuation(code as usize - 26);
}
}
5 => {
if code == 0 {
','
} else if code <= 26 {
char::from(b'a' + code - 1)
} else if code == 30 {
'+'
} else if code == 31 {
'@'
} else {
return punctuation(code as usize - 26);
}
}
6 => {
if code == 0 {
' '
} else if code <= 26 {
char::from(b'a' + code - 1)
} else if code <= 41 {
char::from_u32((code as i32 - 0x20 + b'0' as i32) as u32)
.ok_or_else(|| format!("invalid URI code {code}"))?
} else if code <= 46 {
return punctuation(code as usize - 41);
} else {
return punctuation(code as usize - 47 + 9);
}
}
7 => {
if code == 0 {
' '
} else if code <= 26 {
char::from(b'A' + code - 1)
} else if code <= 31 {
char::from(b'0' + code - 27)
} else if code == 32 {
'_'
} else if code <= 58 {
char::from(b'a' + code - 33)
} else {
char::from(b'5' + code - 59)
}
}
8 => match code {
0 => ' ',
1..=26 => char::from(b'A' + code - 1),
27..=31 => return punctuation(code as usize - 26),
32 => ';',
33..=58 => char::from(b'a' + code - 33),
59..=63 => return punctuation(code as usize - 59 + 9),
_ => return Err(format!("invalid ALPHASYM code {code}")),
},
9 => {
if code < 0x40 {
if code == 0x17 {
'.'
} else if code == 0x37 {
'-'
} else {
char::from_u32(code as u32 + 0xc0)
.ok_or_else(|| format!("invalid European code {code}"))?
}
} else if code == 0x40 {
' '
} else if code == 0x60 {
'_'
} else if (0x5b..0x60).contains(&code) {
char::from(b'0' + code - 0x5b)
} else if (0x7b..0x80).contains(&code) {
char::from(b'5' + code - 0x7b)
} else {
char::from(code)
}
}
11 | 12 => {
if code < 10 {
char::from(b'0' + code)
} else {
char::from(if encoding == 11 { b'a' } else { b'A' } + code - 10)
}
}
_ => return Err(format!("unknown short string encoding {encoding}")),
};
Ok(ascii)
}
fn decode_short_array(blocks: &[u64]) -> std::result::Result<Value, String> {
let first = blocks[0];
let item_type = ((first >> 28) & 0x0f) as u8;
let length = ((first >> 32) & 0x3f) as usize;
let encoded_bits = ((first >> 38) & 0x3f) as usize;
let bits_per_value = if encoded_bits == 0 { 64 } else { encoded_bits };
decode_numeric_values(item_type, length, bits_per_value, |index| {
read_block_bits(blocks, 44 + index * bits_per_value, bits_per_value)
})
}
fn decode_dynamic_array(bytes: &[u8]) -> std::result::Result<Value, String> {
let item_type = *bytes
.first()
.ok_or_else(|| "dynamic array is empty".to_owned())?;
if item_type == 9 {
if bytes.len() < 5 {
return Err("dynamic string array has a truncated header".to_owned());
}
let count = read_u32(&bytes[1..5]) as usize;
let mut offset = 5;
let mut values = Vec::with_capacity(count);
for _ in 0..count {
let length_bytes = bytes
.get(offset..offset + 4)
.ok_or_else(|| "dynamic string array has a truncated item length".to_owned())?;
let length = read_u32(length_bytes) as usize;
offset += 4;
let string = bytes
.get(offset..offset + length)
.ok_or_else(|| "dynamic string array has a truncated item".to_owned())?;
values.push(Value::String(String::from_utf8(string.to_vec()).map_err(
|error| format!("dynamic string array item is invalid UTF-8: {error}"),
)?));
offset += length;
}
if offset != bytes.len() {
return Err("dynamic string array has trailing bytes".to_owned());
}
return Ok(Value::List(values));
}
if item_type > 8 {
return Err(format!("unsupported dynamic array item type {item_type}"));
}
if bytes.len() < 3 {
return Err("dynamic numeric array has a truncated header".to_owned());
}
let bits_in_last_byte = bytes[1] as usize;
let bits_per_value = bytes[2] as usize;
if bits_per_value == 0 {
return Ok(Value::List(Vec::new()));
}
if !(1..=8).contains(&bits_in_last_byte) || bits_per_value > 64 {
return Err("dynamic numeric array has an invalid bit header".to_owned());
}
let body = &bytes[3..];
if body.is_empty() {
return Err("dynamic numeric array body is empty".to_owned());
}
let total_bits = body.len() * 8 - (8 - bits_in_last_byte);
if !total_bits.is_multiple_of(bits_per_value) {
return Err("dynamic numeric array ends with a partial item".to_owned());
}
decode_numeric_values(
item_type,
total_bits / bits_per_value,
bits_per_value,
|index| read_byte_bits(body, index * bits_per_value, bits_per_value),
)
}
fn decode_numeric_values(
item_type: u8,
length: usize,
bits_per_value: usize,
mut read: impl FnMut(usize) -> u64,
) -> std::result::Result<Value, String> {
let mut values = Vec::with_capacity(length);
for index in 0..length {
let raw = read(index);
let value = match item_type {
1 => Value::Boolean(raw != 0),
2 => Value::Integer((raw as u8 as i8) as i64),
3 => Value::Integer((raw as u16 as i16) as i64),
4 => Value::String(
char::from_u32(raw as u32)
.ok_or_else(|| format!("invalid char array value {raw}"))?
.to_string(),
),
5 => Value::Integer((raw as u32 as i32) as i64),
6 => Value::Integer(raw as i64),
7 => Value::Float(f32::from_bits(raw as u32) as f64),
8 => Value::Float(f64::from_bits(raw)),
_ => return Err(format!("unsupported numeric array item type {item_type}")),
};
values.push(value);
}
if bits_per_value == 0 || bits_per_value > 64 {
return Err(format!("invalid array item width {bits_per_value}"));
}
Ok(Value::List(values))
}
fn array_item_type_for_values(values: &[Value]) -> Option<u8> {
match values.first()? {
Value::Boolean(_)
if values
.iter()
.all(|value| matches!(value, Value::Boolean(_))) =>
{
Some(1)
}
Value::Integer(_)
if values
.iter()
.all(|value| matches!(value, Value::Integer(_))) =>
{
Some(6)
}
Value::Float(_) if values.iter().all(|value| matches!(value, Value::Float(_))) => Some(8),
Value::String(_) if values.iter().all(|value| matches!(value, Value::String(_))) => Some(9),
_ => None,
}
}
fn write_block_bits(blocks: &mut [u64], offset: usize, width: usize, value: u64) {
for bit in 0..width {
blocks[(offset + bit) / 64] |= ((value >> bit) & 1) << ((offset + bit) % 64);
}
}
fn read_block_bits(blocks: &[u64], offset: usize, width: usize) -> u64 {
let mut result = 0;
for bit in 0..width {
let source = offset + bit;
result |= ((blocks[source / 64] >> (source % 64)) & 1) << bit;
}
result
}
fn read_byte_bits(bytes: &[u8], offset: usize, width: usize) -> u64 {
let mut result = 0;
for bit in 0..width {
let source = offset + bit;
result |= (((bytes[source / 8] >> (source % 8)) & 1) as u64) << bit;
}
result
}
fn decode_reference(low: u32, modifier: u64) -> Option<u64> {
if modifier == 0 && low == u32::MAX {
None
} else {
Some(modifier | low as u64)
}
}
fn invalid_property(
reader: &RecordReader,
record_id: u64,
context: &str,
message: impl Into<String>,
) -> crate::Error {
Neo4jStoreError::InvalidRecord {
path: PathBuf::from(reader.path()),
record_type: "property".to_owned(),
record_id,
offset: reader.offset(record_id).unwrap_or(u64::MAX),
context: context.to_owned(),
message: message.into(),
}
.into()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reports_physical_scalar_and_array_type_names() {
let dynamic_array_id = 11;
let mut catalog = PropertyCatalog {
records: BTreeMap::from([(
4,
PropertyRecord {
neo4j_id: 4,
previous: None,
next: None,
blocks: vec![
Block {
key_id: 1,
property_type: 2,
values: vec![1 | (2 << 24)],
},
Block {
key_id: 2,
property_type: 7,
values: vec![2 | (7 << 24)],
},
Block {
key_id: 3,
property_type: 10,
values: vec![3 | (10 << 24) | (dynamic_array_id << 28)],
},
Block {
key_id: 4,
property_type: 12,
values: vec![4 | (12 << 24) | (3 << 28)],
},
],
},
)]),
dynamic_array_item_types: BTreeMap::from([(dynamic_array_id, 5)]),
};
assert_eq!(
catalog.type_name_for_key(Some(4), 1).as_deref(),
Some("Byte")
);
assert_eq!(
catalog.type_name_for_key(Some(4), 2).as_deref(),
Some("Float")
);
assert_eq!(
catalog.type_name_for_key(Some(4), 3).as_deref(),
Some("IntegerArray")
);
assert_eq!(
catalog.type_name_for_key(Some(4), 4).as_deref(),
Some("ShortArray")
);
catalog.dynamic_array_item_types.insert(dynamic_array_id, 9);
assert_eq!(
catalog.type_name_for_key(Some(4), 3).as_deref(),
Some("StringArray")
);
}
fn value_block(key: u32, property_type: u8, value: u64) -> u64 {
key as u64 | (property_type as u64) << 24 | value << 28
}
fn property_record(previous: Option<u64>, next: Option<u64>, blocks: &[u64]) -> [u8; 41] {
let previous = previous.unwrap_or(u32::MAX as u64);
let next = next.unwrap_or(u32::MAX as u64);
let mut bytes = [0_u8; 41];
bytes[0] = ((previous >> 32) as u8) << 4 | (next >> 32) as u8;
bytes[1..5].copy_from_slice(&(previous as u32).to_be_bytes());
bytes[5..9].copy_from_slice(&(next as u32).to_be_bytes());
for (index, block) in blocks.iter().enumerate() {
bytes[9 + index * 8..17 + index * 8].copy_from_slice(&block.to_be_bytes());
}
bytes
}
#[test]
fn decodes_record_references_and_scalar_block_counts() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("properties");
std::fs::write(
&path,
property_record(Some(3), Some(0x0f_1234_5678), &[value_block(1, 1, 1)]),
)
.unwrap();
let layout = PageLayout::new(&path, Neo4jStoreFormat::AlignedV5_0, 41).unwrap();
let reader = RecordReader::open(&path, "property", layout).unwrap();
let bytes = std::fs::read(&path).unwrap();
let record = decode_record(&bytes, 0, &reader, "test").unwrap();
assert_eq!(record.previous, Some(3));
assert_eq!(record.next, Some(0x0f_1234_5678));
assert_eq!(record.blocks[0].key_id, 1);
assert_eq!(encode_record(&record).unwrap(), bytes.as_slice());
}
#[test]
fn replaces_inline_scalars_without_changing_block_count() {
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("properties");
std::fs::write(
&path,
property_record(
None,
None,
&[value_block(1, 1, 1), value_block(2, 6, 1) | (42 << 29)],
),
)
.unwrap();
let layout = PageLayout::new(&path, Neo4jStoreFormat::AlignedV5_0, 41).unwrap();
let reader = RecordReader::open(&path, "property", layout).unwrap();
let bytes = std::fs::read(&path).unwrap();
let mut record = decode_record(&bytes, 0, &reader, "test").unwrap();
replace_fixed_size_scalar(&mut record, 1, &Value::Boolean(false)).unwrap();
replace_fixed_size_scalar(&mut record, 2, &Value::Integer(99)).unwrap();
let encoded = encode_record(&record).unwrap();
let decoded = decode_record(&encoded, 0, &reader, "test").unwrap();
assert_eq!(decoded.blocks[0].values, vec![value_block(1, 1, 0)]);
assert_eq!(
decoded.blocks[1].values,
vec![value_block(2, 6, 1) | (99 << 29)]
);
}
#[test]
fn resizes_inline_values_within_property_record_capacity() {
let mut record = PropertyRecord {
neo4j_id: 0,
previous: None,
next: None,
blocks: vec![Block {
key_id: 7,
property_type: 6,
values: vec![value_block(7, 6, 1) | (42 << 29)],
}],
};
replace_fixed_size_scalar(&mut record, 7, &Value::Integer(-1)).unwrap();
assert_eq!(record.blocks[0].values.len(), 2);
replace_fixed_size_scalar(&mut record, 7, &Value::Boolean(true)).unwrap();
assert_eq!(record.blocks[0].values.len(), 1);
let error = replace_fixed_size_scalar(&mut record, 7, &Value::Null).unwrap_err();
assert!(error.contains("short numeric/boolean array"));
record.blocks.extend((8..11).map(|key_id| Block {
key_id,
property_type: 1,
values: vec![value_block(key_id, 1, 1)],
}));
let error = replace_fixed_size_scalar(&mut record, 7, &Value::Integer(-1)).unwrap_err();
assert!(error.contains("needs 5 blocks"));
record.blocks[0].property_type = 9;
record.blocks[0].values = vec![value_block(7, 9, 3)];
let error = replace_fixed_size_scalar(&mut record, 7, &Value::Boolean(true)).unwrap_err();
assert!(error.contains("dynamic record reclamation"));
}
#[test]
fn encodes_two_block_long_and_double_values() {
let mut record = PropertyRecord {
neo4j_id: 0,
previous: Some(0x0f_1234_5678),
next: None,
blocks: vec![Block {
key_id: 3,
property_type: 8,
values: vec![value_block(3, 8, 0), 1.5_f64.to_bits()],
}],
};
replace_fixed_size_scalar(&mut record, 3, &Value::Float(9.5)).unwrap();
let bytes = encode_record(&record).unwrap();
assert_eq!(bytes[0] >> 4, 0x0f);
assert_eq!(
u64::from_be_bytes(bytes[17..25].try_into().unwrap()),
9.5_f64.to_bits()
);
}
#[test]
fn encodes_short_utf8_strings_with_neo4j_bit_layout() {
let encoded = encode_inline_value(5, &Value::String("hé".into())).unwrap();
assert_eq!(encoded.len(), 1);
assert_eq!(decode_short_string(&encoded).unwrap(), "hé");
assert_eq!((encoded[0] >> 24) & 0x0f, 11);
let longest = "x".repeat(27);
let encoded = encode_inline_value(5, &Value::String(longest.clone())).unwrap();
assert_eq!(encoded.len(), PROPERTY_BLOCKS);
assert_eq!(decode_short_string(&encoded).unwrap(), longest);
let error = encode_inline_value(5, &Value::String("x".repeat(28))).unwrap_err();
assert!(error.contains("at most 27"));
}
#[test]
fn encodes_short_boolean_integer_and_float_arrays() {
for value in [
Value::List(vec![
Value::Boolean(true),
Value::Boolean(false),
Value::Boolean(true),
]),
Value::List(vec![Value::Integer(-1), Value::Integer(1 << 40)]),
Value::List(vec![Value::Float(1.5), Value::Float(-2.25)]),
] {
let encoded = encode_inline_value(5, &value).unwrap();
assert_eq!(decode_short_array(&encoded).unwrap(), value);
assert_eq!((encoded[0] >> 24) & 0x0f, 12);
}
}
#[test]
fn rejects_arrays_that_need_dynamic_storage_or_type_metadata() {
let empty = encode_inline_value(5, &Value::List(Vec::new())).unwrap_err();
assert!(empty.contains("component type"));
let mixed =
encode_inline_value(5, &Value::List(vec![Value::Integer(1), Value::Float(2.0)]))
.unwrap_err();
assert!(mixed.contains("homogeneous"));
let long = encode_inline_value(5, &Value::List(vec![Value::Integer(-1); 4])).unwrap_err();
assert!(long.contains("only 4 are available"));
}
#[test]
#[ignore = "requires NEO4J_REAL_FIXTURE generated by tools/neo4j-fixture-generator"]
fn short_integer_array_matches_real_neo4j_blocks_byte_for_byte() {
let database = std::env::var("NEO4J_REAL_FIXTURE").unwrap();
let storage = super::super::Neo4jStorage::open(database).unwrap();
let key_id = storage
.tokens
.property_keys
.iter()
.find_map(|(id, name)| (name == "numbers").then_some(*id))
.unwrap();
let alice = storage
.nodes
.records
.iter()
.find(|node| node.properties.get("name") == Some(&Value::String("Alice".into())))
.unwrap();
let block = storage
.properties
.record_for_key(alice.next_property, key_id)
.unwrap()
.blocks
.iter()
.find(|block| block.key_id == key_id)
.unwrap();
let encoded = encode_inline_value(
key_id,
&Value::List(vec![
Value::Integer(1),
Value::Integer(2),
Value::Integer(3),
Value::Integer(1_i64 << 40),
]),
)
.unwrap();
assert_eq!(encoded, block.values);
}
#[test]
#[ignore = "requires NEO4J_REAL_FIXTURE generated by tools/neo4j-fixture-generator"]
fn dynamic_string_array_matches_real_neo4j_payload_byte_for_byte() {
let database = std::env::var("NEO4J_REAL_FIXTURE").unwrap();
let storage = super::super::Neo4jStorage::open(&database).unwrap();
let key_id = storage
.tokens
.property_keys
.iter()
.find_map(|(id, name)| (name == "tags").then_some(*id))
.unwrap();
let alice = storage
.nodes
.records
.iter()
.find(|node| node.properties.get("name") == Some(&Value::String("Alice".into())))
.unwrap();
let record = storage
.properties
.record_for_key(alice.next_property, key_id)
.unwrap();
let block = record
.blocks
.iter()
.find(|block| block.key_id == key_id)
.unwrap();
assert_eq!(block.property_type, 10);
let first_id = block.values[0] >> 28;
let mut arrays = DynamicStore::open(
&Path::new(&database).join("neostore.propertystore.db.arrays"),
storage.format,
"dynamic array property",
)
.unwrap();
let actual = arrays.read_chain(first_id, "fixture tags").unwrap();
let expected = encode_dynamic_array_payload(&alice.properties["tags"])
.unwrap()
.unwrap();
assert_eq!(actual, expected);
}
#[test]
fn catalog_locates_and_prepares_an_update_across_a_chain() {
let first = PropertyRecord {
neo4j_id: 4,
previous: None,
next: Some(9),
blocks: vec![Block {
key_id: 1,
property_type: 1,
values: vec![value_block(1, 1, 1)],
}],
};
let second = PropertyRecord {
neo4j_id: 9,
previous: Some(4),
next: None,
blocks: vec![Block {
key_id: 7,
property_type: 6,
values: vec![value_block(7, 6, 1) | (42 << 29)],
}],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![first, second]).unwrap();
let (record_id, bytes) =
prepare_fixed_size_update(&catalog, Some(4), 7, &Value::Integer(99)).unwrap();
assert_eq!(record_id, 9);
assert_eq!(bytes[0] >> 4, 0);
assert_eq!(
u64::from_be_bytes(bytes[9..17].try_into().unwrap()),
value_block(7, 6, 1) | (99 << 29)
);
}
#[test]
fn adds_a_fixed_size_property_to_free_record_blocks() {
let record = PropertyRecord {
neo4j_id: 4,
previous: None,
next: None,
blocks: vec![Block {
key_id: 1,
property_type: 1,
values: vec![value_block(1, 1, 1)],
}],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![record]).unwrap();
let update = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::Float(2.5),
None,
None,
None,
)
.unwrap();
let (record_id, bytes) = &update.records[0];
assert_eq!(*record_id, 4);
assert_eq!(
u64::from_be_bytes(bytes[17..25].try_into().unwrap()),
value_block(7, 8, 0)
);
assert_eq!(
u64::from_be_bytes(bytes[25..33].try_into().unwrap()),
2.5_f64.to_bits()
);
}
#[test]
fn adding_a_property_rejects_missing_capacity_or_chain() {
let record = PropertyRecord {
neo4j_id: 4,
previous: None,
next: None,
blocks: (0..PROPERTY_BLOCKS)
.map(|key_id| Block {
key_id: key_id as u32,
property_type: 1,
values: vec![value_block(key_id as u32, 1, 1)],
})
.collect(),
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![record]).unwrap();
assert!(apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::Boolean(true),
None,
None,
None,
)
.unwrap_err()
.contains("allocating a property record"));
assert!(apply_fixed_size_update(
&mut catalog,
None,
7,
&Value::Boolean(true),
None,
None,
None,
)
.unwrap_err()
.contains("allocating a property record"));
}
#[test]
fn allocates_a_new_property_chain_head() {
let record = PropertyRecord {
neo4j_id: 4,
previous: None,
next: Some(8),
blocks: (0..PROPERTY_BLOCKS)
.map(|key_id| Block {
key_id: key_id as u32,
property_type: 1,
values: vec![value_block(key_id as u32, 1, 1)],
})
.collect(),
};
let tail = PropertyRecord {
neo4j_id: 8,
previous: Some(4),
next: None,
blocks: (9..9 + PROPERTY_BLOCKS)
.map(|key_id| Block {
key_id: key_id as u32,
property_type: 1,
values: vec![value_block(key_id as u32, 1, 1)],
})
.collect(),
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![record, tail]).unwrap();
let update = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::Float(2.5),
Some(12),
None,
None,
)
.unwrap();
assert_eq!(update.new_head, Some(12));
assert_eq!(update.records.len(), 2);
assert_eq!(catalog.records[&12].previous, None);
assert_eq!(catalog.records[&12].next, Some(4));
assert_eq!(catalog.records[&4].previous, Some(12));
assert_eq!(catalog.records[&4].next, Some(8));
}
#[test]
fn moves_a_growing_property_to_another_chain_record() {
let source = PropertyRecord {
neo4j_id: 4,
previous: None,
next: Some(8),
blocks: (7..11)
.map(|key_id| Block {
key_id,
property_type: 1,
values: vec![value_block(key_id, 1, 1)],
})
.collect(),
};
let target = PropertyRecord {
neo4j_id: 8,
previous: Some(4),
next: None,
blocks: vec![Block {
key_id: 20,
property_type: 1,
values: vec![value_block(20, 1, 1)],
}],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![source, target]).unwrap();
let update = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::Float(2.5),
None,
None,
None,
)
.unwrap();
assert_eq!(update.records.len(), 2);
assert!(catalog.records[&4]
.blocks
.iter()
.all(|block| block.key_id != 7));
assert_eq!(catalog.records[&8].blocks.last().unwrap().key_id, 7);
assert_eq!(catalog.records[&8].blocks.last().unwrap().values.len(), 2);
assert_eq!(catalog.record_for_key(Some(4), 7).unwrap().neo4j_id, 8);
}
#[test]
fn moves_a_growing_property_into_a_new_chain_head() {
let source = PropertyRecord {
neo4j_id: 4,
previous: None,
next: Some(8),
blocks: (7..11)
.map(|key_id| Block {
key_id,
property_type: 1,
values: vec![value_block(key_id, 1, 1)],
})
.collect(),
};
let tail = PropertyRecord {
neo4j_id: 8,
previous: Some(4),
next: None,
blocks: (20..24)
.map(|key_id| Block {
key_id,
property_type: 1,
values: vec![value_block(key_id, 1, 1)],
})
.collect(),
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![source, tail]).unwrap();
let before = catalog.records.clone();
let error = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::Float(2.5),
None,
None,
None,
)
.unwrap_err();
assert!(error.contains("allocating a property record"));
assert_eq!(catalog.records, before);
let update = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::Float(2.5),
Some(12),
None,
None,
)
.unwrap();
assert_eq!(update.new_head, Some(12));
assert_eq!(update.records.len(), 2);
assert_eq!(catalog.records[&12].next, Some(4));
assert_eq!(catalog.records[&4].previous, Some(12));
assert_eq!(catalog.records[&4].blocks.len(), 3);
assert_eq!(catalog.record_for_key(Some(12), 7).unwrap().neo4j_id, 12);
}
#[test]
fn replaces_an_inline_string_with_a_dynamic_reference() {
let encoded_short = encode_inline_value(7, &Value::String("a".to_owned())).unwrap();
let record = PropertyRecord {
neo4j_id: 4,
previous: None,
next: None,
blocks: vec![Block {
key_id: 7,
property_type: 11,
values: encoded_short,
}],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![record]).unwrap();
let update = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::String("x".repeat(40)),
None,
Some(19),
None,
)
.unwrap();
let first = u64::from_be_bytes(update.records[0].1[9..17].try_into().unwrap());
assert_eq!((first >> 24) & 0x0f, 9);
assert_eq!(first >> 28, 19);
let replacement = apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::String("y".repeat(40)),
None,
Some(20),
None,
)
.expect("the writable layer handles old dynamic record reclamation");
let first = u64::from_be_bytes(replacement.records[0].1[9..17].try_into().unwrap());
assert_eq!(first >> 28, 20);
apply_fixed_size_update(
&mut catalog,
Some(4),
7,
&Value::String("z".repeat(40)),
None,
Some(19),
None,
)
.expect("replacing a dynamic pointer is safe after reclamation is prepared");
}
#[test]
fn encodes_dynamic_numeric_and_string_array_payloads() {
for value in [
Value::List(vec![Value::Boolean(true); 100]),
Value::List((0..100).map(Value::Integer).collect()),
Value::List(vec![Value::Float(1.5); 8]),
Value::List(vec![
Value::String("graph".to_owned()),
Value::String("数据库".to_owned()),
]),
] {
let payload = encode_dynamic_array_payload(&value)
.unwrap()
.expect("value exceeds inline array support");
assert_eq!(decode_dynamic_array(&payload).unwrap(), value);
}
assert!(encode_dynamic_array_payload(&Value::List(Vec::new()))
.unwrap_err()
.contains("component type"));
assert!(encode_dynamic_array_payload(&Value::List(vec![
Value::Integer(1),
Value::Float(2.0),
]))
.unwrap_err()
.contains("homogeneous"));
}
#[test]
fn encodes_a_dynamic_array_property_reference() {
let mut catalog = PropertyCatalog::default();
let update = apply_fixed_size_update(
&mut catalog,
None,
7,
&Value::List(vec![Value::Integer(1); 100]),
Some(12),
None,
Some(23),
)
.unwrap();
let first = u64::from_be_bytes(update.records[0].1[9..17].try_into().unwrap());
assert_eq!((first >> 24) & 0x0f, 10);
assert_eq!(first >> 28, 23);
apply_fixed_size_update(
&mut catalog,
Some(12),
7,
&Value::List(vec![Value::Integer(2); 100]),
None,
None,
Some(23),
)
.expect("reusing the existing dynamic array pointer is safe");
}
#[test]
fn catalog_rejects_shared_property_records() {
let record = PropertyRecord {
neo4j_id: 3,
previous: None,
next: None,
blocks: vec![Block {
key_id: 1,
property_type: 1,
values: vec![value_block(1, 1, 1)],
}],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![record.clone()]).unwrap();
let error = catalog.insert_chain(vec![record]).unwrap_err();
assert!(error
.to_string()
.contains("referenced by more than one entity"));
}
#[test]
fn removes_and_compacts_an_inline_property_block() {
let record = PropertyRecord {
neo4j_id: 3,
previous: None,
next: None,
blocks: vec![
Block {
key_id: 1,
property_type: 8,
values: vec![value_block(1, 8, 0), 1.5_f64.to_bits()],
},
Block {
key_id: 2,
property_type: 1,
values: vec![value_block(2, 1, 1)],
},
],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![record]).unwrap();
let mutation = apply_removal(&mut catalog, Some(3), 1)
.unwrap()
.expect("existing property");
let (record_id, bytes) = &mutation.records[0];
assert_eq!(*record_id, 3);
assert_eq!(
u64::from_be_bytes(bytes[9..17].try_into().unwrap()),
value_block(2, 1, 1)
);
assert!(bytes[17..].iter().all(|byte| *byte == 0));
assert_eq!(mutation.owner_head, None);
assert_eq!(mutation.freed_record_id, None);
assert_eq!(mutation.dynamic, None);
}
#[test]
fn removes_a_sole_property_by_unlinking_the_chain_head() {
let target = PropertyRecord {
neo4j_id: 3,
previous: None,
next: Some(4),
blocks: vec![Block {
key_id: 1,
property_type: 1,
values: vec![value_block(1, 1, 1)],
}],
};
let donor = PropertyRecord {
neo4j_id: 4,
previous: Some(3),
next: None,
blocks: vec![
Block {
key_id: 2,
property_type: 1,
values: vec![value_block(2, 1, 1)],
},
Block {
key_id: 3,
property_type: 9,
values: vec![value_block(3, 9, 7)],
},
],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![target, donor]).unwrap();
let mutation = apply_removal(&mut catalog, Some(3), 1)
.unwrap()
.expect("existing property");
assert_eq!(mutation.records.len(), 2);
assert_eq!(mutation.owner_head, Some(Some(4)));
assert_eq!(mutation.freed_record_id, Some(3));
assert_eq!(mutation.dynamic, None);
assert!(!catalog.records.contains_key(&3));
assert_eq!(catalog.records[&4].previous, None);
assert_eq!(catalog.records[&4].blocks.len(), 2);
assert_eq!(catalog.record_for_key(Some(4), 1), None);
assert_eq!(catalog.record_for_key(Some(4), 3).unwrap().neo4j_id, 4);
}
#[test]
fn removes_a_sole_property_by_unlinking_a_middle_record() {
let head = PropertyRecord {
neo4j_id: 3,
previous: None,
next: Some(4),
blocks: vec![Block {
key_id: 1,
property_type: 1,
values: vec![value_block(1, 1, 1)],
}],
};
let target = PropertyRecord {
neo4j_id: 4,
previous: Some(3),
next: Some(5),
blocks: vec![Block {
key_id: 2,
property_type: 1,
values: vec![value_block(2, 1, 1)],
}],
};
let tail = PropertyRecord {
neo4j_id: 5,
previous: Some(4),
next: None,
blocks: vec![Block {
key_id: 3,
property_type: 1,
values: vec![value_block(3, 1, 1)],
}],
};
let mut invalid_tail = tail.clone();
invalid_tail.previous = Some(99);
let mut invalid_catalog = PropertyCatalog::default();
invalid_catalog
.insert_chain(vec![head.clone(), target.clone(), invalid_tail])
.unwrap();
let before = invalid_catalog.records.clone();
let error = apply_removal(&mut invalid_catalog, Some(3), 2).unwrap_err();
assert!(error.contains("does not reference"));
assert_eq!(invalid_catalog.records, before);
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![head, target, tail]).unwrap();
let mutation = apply_removal(&mut catalog, Some(3), 2)
.unwrap()
.expect("existing middle property");
assert_eq!(mutation.records.len(), 3);
assert_eq!(mutation.owner_head, None);
assert_eq!(mutation.freed_record_id, Some(4));
assert!(!catalog.records.contains_key(&4));
assert_eq!(catalog.records[&3].next, Some(5));
assert_eq!(catalog.records[&5].previous, Some(3));
assert_eq!(catalog.record_for_key(Some(3), 2), None);
}
#[test]
fn removal_reports_chain_unlinking_and_dynamic_reclamation() {
let sole = PropertyRecord {
neo4j_id: 3,
previous: None,
next: None,
blocks: vec![Block {
key_id: 1,
property_type: 1,
values: vec![value_block(1, 1, 1)],
}],
};
let dynamic = PropertyRecord {
neo4j_id: 4,
previous: None,
next: None,
blocks: vec![
Block {
key_id: 2,
property_type: 9,
values: vec![value_block(2, 9, 7)],
},
Block {
key_id: 3,
property_type: 1,
values: vec![value_block(3, 1, 1)],
},
],
};
let mut catalog = PropertyCatalog::default();
catalog.insert_chain(vec![sole, dynamic]).unwrap();
let sole = apply_removal(&mut catalog, Some(3), 1)
.unwrap()
.expect("existing sole property");
assert_eq!(sole.owner_head, Some(None));
assert_eq!(sole.freed_record_id, Some(3));
let dynamic = apply_removal(&mut catalog, Some(4), 2)
.unwrap()
.expect("existing dynamic property");
assert_eq!(dynamic.owner_head, None);
assert_eq!(dynamic.freed_record_id, None);
assert_eq!(
dynamic.dynamic,
Some(DynamicPropertyReference {
kind: DynamicPropertyKind::String,
first_record_id: 7,
})
);
assert!(apply_removal(&mut catalog, Some(4), 99).unwrap().is_none());
}
#[test]
fn recognizes_multi_block_and_variable_length_encodings() {
assert_eq!(block_count(value_block(0, 6, 0), 6), Some(2));
assert_eq!(block_count(value_block(0, 6, 1), 6), Some(1));
assert_eq!(block_count(value_block(0, 8, 0), 8), Some(2));
let short = value_block(0, 11, 0) | (10 << 33);
assert_eq!(block_count(short, 11), Some(2));
let array = value_block(0, 12, 0) | (3 << 32) | (5 << 38);
assert_eq!(block_count(array, 12), Some(1));
}
fn put_bits(target: &mut [u64], offset: usize, width: usize, value: u64) {
for bit in 0..width {
target[(offset + bit) / 64] |= ((value >> bit) & 1) << ((offset + bit) % 64);
}
}
#[test]
fn decodes_utf8_latin1_and_compact_short_strings() {
let mut utf8 = [0_u64; 2];
put_bits(&mut utf8, 24, 4, 11);
put_bits(&mut utf8, 28, 5, 0);
put_bits(&mut utf8, 33, 6, 5);
for (index, byte) in b"hello".iter().enumerate() {
put_bits(&mut utf8, 39 + index * 8, 8, *byte as u64);
}
assert_eq!(decode_short_string(&utf8).unwrap(), "hello");
let mut latin = [0_u64; 2];
put_bits(&mut latin, 24, 4, 11);
put_bits(&mut latin, 28, 5, 10);
put_bits(&mut latin, 33, 6, 2);
put_bits(&mut latin, 39, 8, 0xe9);
put_bits(&mut latin, 47, 8, b'!'.into());
assert_eq!(decode_short_string(&latin).unwrap(), "é!");
let mut compact = [0_u64; 1];
put_bits(&mut compact, 24, 4, 11);
put_bits(&mut compact, 28, 5, 7);
put_bits(&mut compact, 33, 6, 3);
put_bits(&mut compact, 39, 6, 1); put_bits(&mut compact, 45, 6, 2); put_bits(&mut compact, 51, 6, 0); assert_eq!(decode_short_string(&compact).unwrap(), "AB ");
}
#[test]
fn decodes_short_and_dynamic_numeric_and_string_arrays() {
let mut short = [0_u64; 2];
put_bits(&mut short, 24, 4, 12); put_bits(&mut short, 28, 4, 5); put_bits(&mut short, 32, 6, 3);
put_bits(&mut short, 38, 6, 4);
put_bits(&mut short, 44, 4, 1);
put_bits(&mut short, 48, 4, 2);
put_bits(&mut short, 52, 4, 15);
assert_eq!(
decode_short_array(&short).unwrap(),
Value::List(vec![
Value::Integer(1),
Value::Integer(2),
Value::Integer(15)
])
);
let dynamic_numeric = [2_u8, 8, 8, 1, 2, 255];
assert_eq!(
decode_dynamic_array(&dynamic_numeric).unwrap(),
Value::List(vec![
Value::Integer(1),
Value::Integer(2),
Value::Integer(-1)
])
);
let mut dynamic_strings = vec![9, 0, 0, 0, 2];
dynamic_strings.extend_from_slice(&[0, 0, 0, 1, b'a', 0, 0, 0, 2, b'b', b'c']);
assert_eq!(
decode_dynamic_array(&dynamic_strings).unwrap(),
Value::List(vec![Value::String("a".into()), Value::String("bc".into())])
);
}
}