mod checkpoint;
#[allow(dead_code)]
mod counts;
mod dynamic;
mod id_generator;
mod layout;
mod mvcc;
mod node;
mod page;
mod property;
mod relationship;
#[allow(dead_code)]
mod relationship_group;
mod schema;
mod token;
mod transaction;
#[cfg(test)]
pub(crate) use transaction::fail_next_commit_after_patch;
mod workspace_spill;
mod writable;
pub(crate) use writable::{Neo4jWritableSavepoint, Neo4jWritableStorage};
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use crate::error::{Error, Result, TransactionErrorKind};
use crate::graph_model::{Node, NodeId, Relationship, RelationshipId};
use crate::storage_interface::{DatabaseMetadata, SchemaMetadata, StorageInterface};
pub use layout::Neo4jStoreFormat;
#[derive(Clone, Debug)]
pub struct Neo4jStorage {
_lock: Option<Arc<transaction::DatabaseLock>>,
database_directory: PathBuf,
database_metadata: DatabaseMetadata,
format: Neo4jStoreFormat,
tokens: token::TokenCatalog,
schema: SchemaMetadata,
nodes: node::NodeCatalog,
relationships: relationship::RelationshipCatalog,
#[allow(dead_code)]
relationship_groups: Box<relationship_group::RelationshipGroupCatalog>,
properties: property::PropertyCatalog,
query_nodes: Vec<Node>,
query_relationships: Vec<Relationship>,
deleted: Box<DeletedEntities>,
outgoing: Vec<Vec<RelationshipId>>,
incoming: Vec<Vec<RelationshipId>>,
label_index: BTreeMap<String, Vec<NodeId>>,
}
pub(super) struct StagedPropertyUpdate {
pub(super) property_records: Vec<(u64, [u8; 41])>,
pub(super) new_head: Option<u64>,
pub(super) owner_record_id: u64,
}
pub(in crate::neo4j_storage) struct StagedPropertyRemoval {
pub(in crate::neo4j_storage) property_records: Vec<(u64, [u8; 41])>,
pub(in crate::neo4j_storage) owner_record_id: u64,
pub(in crate::neo4j_storage) owner_head: Option<Option<u64>>,
pub(in crate::neo4j_storage) freed_record_id: Option<u64>,
pub(in crate::neo4j_storage) dynamic: Option<property::DynamicPropertyReference>,
}
type RelationshipHeadPatch = Option<(u64, [u8; 34])>;
#[derive(Clone, Debug, Default)]
struct DeletedEntities {
nodes: BTreeSet<NodeId>,
relationships: BTreeSet<RelationshipId>,
}
pub(super) struct DeletedRelationship {
pub(super) neo4j_id: u64,
pub(super) start: NodeId,
pub(super) end: NodeId,
pub(super) type_id: u32,
pub(super) node_heads: Vec<(u64, Option<u64>)>,
pub(super) record_patches: BTreeMap<u64, [u8; 34]>,
pub(super) group_patches: BTreeMap<u64, [u8; 25]>,
pub(super) degree_deltas: Vec<(u64, u8, i64)>,
pub(super) freed_group_records: BTreeSet<u64>,
}
pub(super) struct DeletedNode {
pub(super) neo4j_id: u64,
pub(super) label_ids: Vec<u32>,
}
pub(super) struct DenseRelationshipHead {
pub(super) group_id: u64,
pub(super) previous: Option<u64>,
pub(super) next: Option<u64>,
pub(super) degree_delta: Option<i64>,
pub(super) group_patch: [u8; 25],
pub(super) relationship_patch: Option<(u64, [u8; 34])>,
}
pub(super) struct DenseRelationshipGroupCreation {
pub(super) group_patch: [u8; 25],
pub(super) previous_patch: Option<(u64, [u8; 25])>,
pub(super) node_head: Option<u64>,
}
#[derive(Debug, PartialEq, Eq)]
pub(super) struct SparseDenseGroupPlan {
pub(super) type_id: u32,
pub(super) outgoing: Vec<u64>,
pub(super) incoming: Vec<u64>,
pub(super) loops: Vec<u64>,
}
fn relationship_record_mut(
records: &mut [relationship::RelationshipRecord],
neo4j_id: u64,
) -> Result<&mut relationship::RelationshipRecord> {
records
.iter_mut()
.find(|record| record.neo4j_id == neo4j_id)
.ok_or_else(|| {
crate::Error::Validation(format!(
"relationship chain references unloaded record {neo4j_id}"
))
})
}
fn chain_state(
record: &relationship::RelationshipRecord,
node_id: u64,
) -> Result<(Option<u64>, Option<u64>, bool, u64)> {
let mut states = Vec::new();
if record.start == node_id {
states.push((
record.first_previous,
record.first_next,
record.first_in_start_chain,
));
}
if record.end == node_id {
states.push((
record.second_previous,
record.second_next,
record.first_in_end_chain,
));
}
let state = states.first().copied().ok_or_else(|| {
crate::Error::Validation(format!(
"relationship {} does not reference node {node_id}",
record.neo4j_id
))
})?;
if states.iter().any(|candidate| *candidate != state) {
return Err(crate::Error::Validation(format!(
"loop relationship {} has inconsistent chain fields",
record.neo4j_id
)));
}
let degree = if state.2 {
state.0.ok_or_else(|| {
crate::Error::Validation("relationship chain head has no degree".to_owned())
})?
} else {
0
};
Ok((state.0, state.1, state.2, degree))
}
fn set_chain_previous(
record: &mut relationship::RelationshipRecord,
node_id: u64,
first: bool,
value: u64,
) -> Result<()> {
let mut matched = false;
if record.start == node_id {
record.first_previous = Some(value);
record.first_in_start_chain = first;
matched = true;
}
if record.end == node_id {
record.second_previous = Some(value);
record.first_in_end_chain = first;
matched = true;
}
if !matched {
return Err(crate::Error::Validation(format!(
"relationship {} does not reference node {node_id}",
record.neo4j_id
)));
}
Ok(())
}
fn set_chain_next(
record: &mut relationship::RelationshipRecord,
node_id: u64,
next: Option<u64>,
) -> Result<()> {
let mut matched = false;
if record.start == node_id {
record.first_next = next;
matched = true;
}
if record.end == node_id {
record.second_next = next;
matched = true;
}
if !matched {
return Err(crate::Error::Validation(format!(
"relationship {} does not reference node {node_id}",
record.neo4j_id
)));
}
Ok(())
}
impl Neo4jStorage {
pub(super) fn estimated_clone_heap_bytes(&self) -> Result<usize> {
fn add(bytes: &mut usize, value: usize) -> Result<()> {
*bytes = bytes
.checked_add(value)
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?;
Ok(())
}
let mut bytes = std::mem::size_of::<Self>();
add(
&mut bytes,
std::mem::size_of::<relationship_group::RelationshipGroupCatalog>(),
)?;
add(&mut bytes, std::mem::size_of::<DeletedEntities>())?;
add(
&mut bytes,
self.database_directory.as_os_str().as_encoded_bytes().len(),
)?;
add(
&mut bytes,
self.query_nodes
.len()
.checked_mul(std::mem::size_of::<Node>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for node in &self.query_nodes {
add(&mut bytes, node.external_id.len())?;
add(
&mut bytes,
node.labels
.len()
.checked_mul(std::mem::size_of::<String>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for label in &node.labels {
add(&mut bytes, label.len())?;
}
add(
&mut bytes,
crate::value::estimated_properties_heap_bytes(&node.properties)
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
add(
&mut bytes,
self.query_relationships
.len()
.checked_mul(std::mem::size_of::<Relationship>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for relationship in &self.query_relationships {
add(&mut bytes, relationship.external_id.len())?;
add(&mut bytes, relationship.r#type.len())?;
add(
&mut bytes,
crate::value::estimated_properties_heap_bytes(&relationship.properties)
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
for adjacency in [&self.outgoing, &self.incoming] {
add(
&mut bytes,
adjacency
.len()
.checked_mul(std::mem::size_of::<Vec<RelationshipId>>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for ids in adjacency {
add(
&mut bytes,
ids.len()
.checked_mul(std::mem::size_of::<RelationshipId>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
}
for (label, ids) in &self.label_index {
add(
&mut bytes,
std::mem::size_of::<String>()
+ std::mem::size_of::<Vec<NodeId>>()
+ 3 * std::mem::size_of::<usize>(),
)?;
add(&mut bytes, label.len())?;
add(
&mut bytes,
ids.len()
.checked_mul(std::mem::size_of::<NodeId>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
add(
&mut bytes,
self.deleted
.nodes
.len()
.checked_add(self.deleted.relationships.len())
.and_then(|count| {
count.checked_mul(
std::mem::size_of::<usize>() + 3 * std::mem::size_of::<usize>(),
)
})
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for tokens in [
&self.tokens.labels,
&self.tokens.relationship_types,
&self.tokens.property_keys,
] {
for name in tokens.values() {
add(
&mut bytes,
std::mem::size_of::<u32>()
+ std::mem::size_of::<String>()
+ 3 * std::mem::size_of::<usize>()
+ name.len(),
)?;
}
}
add(
&mut bytes,
self.nodes
.records
.len()
.checked_mul(std::mem::size_of::<node::NodeRecord>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for record in &self.nodes.records {
add(
&mut bytes,
record
.labels
.len()
.checked_mul(std::mem::size_of::<String>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for label in &record.labels {
add(&mut bytes, label.len())?;
}
add(
&mut bytes,
crate::value::estimated_properties_heap_bytes(&record.properties)
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
for (label, ids) in &self.nodes.label_index {
add(
&mut bytes,
std::mem::size_of::<String>()
+ std::mem::size_of::<Vec<u64>>()
+ 3 * std::mem::size_of::<usize>()
+ label.len(),
)?;
add(
&mut bytes,
ids.len()
.checked_mul(std::mem::size_of::<u64>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
add(
&mut bytes,
self.relationships
.records
.len()
.checked_mul(std::mem::size_of::<relationship::RelationshipRecord>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for record in &self.relationships.records {
add(
&mut bytes,
crate::value::estimated_properties_heap_bytes(&record.properties)
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
for adjacency in [&self.relationships.outgoing, &self.relationships.incoming] {
for ids in adjacency.values() {
add(
&mut bytes,
std::mem::size_of::<u64>()
+ std::mem::size_of::<Vec<u64>>()
+ 3 * std::mem::size_of::<usize>(),
)?;
add(
&mut bytes,
ids.len()
.checked_mul(std::mem::size_of::<u64>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
}
add(
&mut bytes,
self.relationship_groups
.records
.len()
.checked_mul(std::mem::size_of::<(
u64,
relationship_group::RelationshipGroupRecord,
)>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
for ids in self.relationship_groups.by_node.values() {
add(
&mut bytes,
std::mem::size_of::<u64>()
+ std::mem::size_of::<Vec<u64>>()
+ 3 * std::mem::size_of::<usize>(),
)?;
add(
&mut bytes,
ids.len()
.checked_mul(std::mem::size_of::<u64>())
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
}
add(
&mut bytes,
self.properties
.estimated_heap_bytes()
.ok_or(Error::Transaction(TransactionErrorKind::ResourceLimit))?,
)?;
Ok(bytes)
}
pub fn initialize_if_empty(database_directory: impl AsRef<Path>) -> Result<bool> {
layout::initialize_if_empty(database_directory.as_ref())
}
pub fn open(database_directory: impl AsRef<Path>) -> Result<Self> {
let database_directory = database_directory.as_ref();
let lock_path = database_directory.join("database_lock");
match std::fs::symlink_metadata(&lock_path) {
Ok(_) => {}
Err(source) if source.kind() == std::io::ErrorKind::NotFound => {
layout::validate(database_directory)?;
}
Err(source) => {
return Err(crate::Neo4jStoreError::DatabaseLock {
path: lock_path,
source,
}
.into());
}
}
let lock = Arc::new(transaction::DatabaseLock::acquire_shared(
database_directory,
)?);
Self::open_with_lock(database_directory, Some(lock))
}
pub(super) fn open_unlocked(database_directory: impl AsRef<Path>) -> Result<Self> {
Self::open_with_lock(database_directory.as_ref(), None)
}
fn open_with_lock(
database_directory: &Path,
lock: Option<Arc<transaction::DatabaseLock>>,
) -> Result<Self> {
transaction::ensure_no_pending_journal(database_directory)?;
let format = layout::validate(database_directory)?;
let store_metadata = layout::read_metadata(database_directory)?;
let database_metadata = DatabaseMetadata {
name: database_directory
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_default(),
external_store_id: store_metadata.external_store_id,
creation_time_millis: store_metadata.creation_time_millis,
};
let tokens = token::load(database_directory, format)?;
let schema = schema::load(
database_directory,
format,
&tokens.labels,
&tokens.relationship_types,
&tokens.property_keys,
)?;
let mut nodes = node::load(database_directory, format, &tokens.labels)?;
let mut properties = property::load_node_properties(
database_directory,
format,
&tokens.property_keys,
&mut nodes.records,
)?;
let node_ids = nodes.records.iter().map(|node| node.neo4j_id).collect();
let mut relationships = relationship::load(
database_directory,
format,
&tokens.relationship_types,
&node_ids,
nodes
.records
.iter()
.map(|node| (node.neo4j_id, node.next_relationship, node.dense)),
)?;
let relationship_properties = property::load_relationship_properties(
database_directory,
format,
&tokens.property_keys,
&mut relationships.records,
)?;
let relationship_ids = relationships
.records
.iter()
.map(|relationship| relationship.neo4j_id)
.collect::<BTreeSet<_>>();
let relationship_group_path = database_directory.join("neostore.relationshipgroupstore.db");
let dense_node_heads = nodes
.records
.iter()
.filter(|node| node.dense)
.map(|node| (node.neo4j_id, node.next_relationship))
.collect::<BTreeMap<_, _>>();
let relationship_groups = if relationship_group_path.exists() {
relationship_group::load(
database_directory,
format,
&node_ids,
&dense_node_heads,
&relationship_ids,
&tokens.relationship_types.keys().copied().collect(),
)?
} else {
relationship_group::RelationshipGroupCatalog::default()
};
properties.merge(relationship_properties)?;
let (query_nodes, query_relationships, outgoing, incoming, label_index) =
build_query_view(&nodes, &relationships, &tokens.relationship_types)?;
Ok(Self {
_lock: lock,
database_directory: database_directory.to_path_buf(),
database_metadata,
format,
tokens,
schema,
nodes,
relationships,
relationship_groups: Box::new(relationship_groups),
properties,
query_nodes,
query_relationships,
deleted: Box::new(DeletedEntities::default()),
outgoing,
incoming,
label_index,
})
}
pub fn database_directory(&self) -> &Path {
&self.database_directory
}
pub fn format(&self) -> Neo4jStoreFormat {
self.format
}
pub fn label_tokens(&self) -> &BTreeMap<u32, String> {
&self.tokens.labels
}
pub fn relationship_type_tokens(&self) -> &BTreeMap<u32, String> {
&self.tokens.relationship_types
}
pub fn property_key_tokens(&self) -> &BTreeMap<u32, String> {
&self.tokens.property_keys
}
fn public_label_token_names(&self) -> Vec<String> {
public_token_names(&self.tokens.labels, &self.tokens.internal_labels)
}
fn public_relationship_type_token_names(&self) -> Vec<String> {
public_token_names(
&self.tokens.relationship_types,
&self.tokens.internal_relationship_types,
)
}
fn public_property_key_token_names(&self) -> Vec<String> {
public_token_names(
&self.tokens.property_keys,
&self.tokens.internal_property_keys,
)
}
#[allow(dead_code)]
pub(crate) fn prepare_node_property_update(
&self,
node_id: NodeId,
key: &str,
value: &crate::Value,
) -> Result<(u64, [u8; 41])> {
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
self.prepare_property_update(node.next_property, key, value)
}
#[allow(dead_code)]
pub(crate) fn prepare_relationship_property_update(
&self,
relationship_id: RelationshipId,
key: &str,
value: &crate::Value,
) -> Result<(u64, [u8; 41])> {
let relationship = self
.relationships
.records
.get(relationship_id)
.ok_or_else(|| {
crate::Error::Execution(format!("relationship id {relationship_id} does not exist"))
})?;
self.prepare_property_update(relationship.next_property, key, value)
}
fn prepare_property_update(
&self,
first_property: Option<u64>,
key: &str,
value: &crate::Value,
) -> Result<(u64, [u8; 41])> {
let key_id = self
.tokens
.property_keys
.iter()
.find_map(|(id, name)| (name == key).then_some(*id))
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(format!(
"Neo4j property key token `{key}` does not exist"
))
})?;
property::prepare_fixed_size_update(&self.properties, first_property, key_id, value)
.map_err(crate::Error::UnsupportedWriteQuery)
}
fn property_key_id(&self, key: &str) -> Result<u32> {
self.tokens
.property_keys
.iter()
.find_map(|(id, name)| (name == key).then_some(*id))
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(format!(
"Neo4j property key token `{key}` does not exist"
))
})
}
pub(super) fn has_property_key(&self, key: &str) -> bool {
self.tokens.property_keys.values().any(|name| name == key)
}
pub(super) fn has_label(&self, label: &str) -> bool {
self.tokens.labels.values().any(|name| name == label)
}
pub(super) fn has_relationship_type(&self, relationship_type: &str) -> bool {
self.tokens
.relationship_types
.values()
.any(|name| name == relationship_type)
}
pub(super) fn insert_label_token(&mut self, id: u32, label: String) -> Result<()> {
if self.tokens.labels.contains_key(&id) {
return Err(crate::Error::Validation(format!(
"Neo4j label token ID {id} is already in use"
)));
}
if self.has_label(&label) {
return Err(crate::Error::Validation(format!(
"Neo4j label token `{label}` already exists"
)));
}
self.tokens.labels.insert(id, label);
Ok(())
}
pub(super) fn insert_property_key_token(&mut self, id: u32, key: String) -> Result<()> {
if self.tokens.property_keys.contains_key(&id) {
return Err(crate::Error::Validation(format!(
"Neo4j property key token ID {id} is already in use"
)));
}
if self.has_property_key(&key) {
return Err(crate::Error::Validation(format!(
"Neo4j property key token `{key}` already exists"
)));
}
self.tokens.property_keys.insert(id, key);
Ok(())
}
pub(super) fn insert_relationship_type_token(
&mut self,
id: u32,
relationship_type: String,
) -> Result<()> {
if self.tokens.relationship_types.contains_key(&id) {
return Err(crate::Error::Validation(format!(
"Neo4j relationship type token ID {id} is already in use"
)));
}
if self.has_relationship_type(&relationship_type) {
return Err(crate::Error::Validation(format!(
"Neo4j relationship type token `{relationship_type}` already exists"
)));
}
self.tokens.relationship_types.insert(id, relationship_type);
Ok(())
}
pub(super) fn existing_labels(&self, labels: &[String]) -> Result<Vec<(u32, String)>> {
let mut resolved = labels
.iter()
.map(|label| {
self.tokens
.labels
.iter()
.find_map(|(id, name)| (name == label).then(|| (*id, name.clone())))
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(format!(
"Neo4j label token `{label}` does not exist"
))
})
})
.collect::<Result<Vec<_>>>()?;
resolved.sort_unstable_by_key(|(id, _)| *id);
if resolved.windows(2).any(|pair| pair[0].0 == pair[1].0) {
return Err(crate::Error::Validation(
"CREATE node contains a duplicate label".to_owned(),
));
}
Ok(resolved)
}
pub(super) fn insert_node(
&mut self,
neo4j_id: u64,
labels: Vec<(u32, String)>,
) -> Result<NodeId> {
let existing_id = self
.nodes
.records
.iter()
.position(|node| node.neo4j_id == neo4j_id);
if existing_id.is_some_and(|id| !self.deleted.nodes.contains(&id)) {
return Err(crate::Error::Validation(format!(
"Neo4j node record ID {neo4j_id} is already in use"
)));
}
let id = existing_id.unwrap_or(self.query_nodes.len());
let label_names = labels
.iter()
.map(|(_, name)| name.clone())
.collect::<Vec<_>>();
let record = node::NodeRecord {
neo4j_id,
next_property: None,
next_relationship: None,
dense: false,
labels: label_names.clone(),
properties: crate::value::Properties::new(),
};
let query_node = Node {
id,
external_id: neo4j_id.to_string(),
labels: label_names,
properties: crate::value::Properties::new(),
};
if existing_id.is_some() {
self.nodes.records[id] = record;
self.query_nodes[id] = query_node;
self.outgoing[id].clear();
self.incoming[id].clear();
self.deleted.nodes.remove(&id);
} else {
self.nodes.records.push(record);
self.query_nodes.push(query_node);
self.outgoing.push(Vec::new());
self.incoming.push(Vec::new());
}
for (_, label) in labels {
self.nodes
.label_index
.entry(label.clone())
.or_default()
.push(neo4j_id);
self.label_index.entry(label).or_default().push(id);
}
Ok(id)
}
pub(super) fn node_neo4j_id(&self, id: NodeId) -> Result<u64> {
self.nodes
.records
.get(id)
.map(|node| node.neo4j_id)
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))
}
pub(super) fn relationship_type_id(&self, relationship_type: &str) -> Result<u32> {
self.tokens
.relationship_types
.iter()
.find_map(|(id, name)| (name == relationship_type).then_some(*id))
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(format!(
"Neo4j relationship type token `{relationship_type}` does not exist"
))
})
}
pub(super) fn node_relationship_state(&self, id: NodeId) -> Result<(u64, Option<u64>, bool)> {
self.nodes
.records
.get(id)
.map(|node| (node.neo4j_id, node.next_relationship, node.dense))
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))
}
#[allow(dead_code)]
pub(super) fn sparse_relationship_chain(&self, id: NodeId) -> Result<Vec<u64>> {
let node = self
.nodes
.records
.get(id)
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))?;
if node.dense {
return Err(crate::Error::Validation(format!(
"Neo4j node {} is already dense",
node.neo4j_id
)));
}
let mut chain = Vec::new();
let mut seen = BTreeSet::new();
let mut current = node.next_relationship;
let mut expected_previous = None;
while let Some(record_id) = current {
if !seen.insert(record_id) {
return Err(crate::Error::Validation(format!(
"sparse relationship chain for node {} contains a cycle",
node.neo4j_id
)));
}
let record = self
.relationships
.records
.iter()
.find(|record| record.neo4j_id == record_id)
.ok_or_else(|| {
crate::Error::Validation(format!(
"sparse relationship chain references missing record {record_id}"
))
})?;
let (previous, next, first, _) = chain_state(record, node.neo4j_id)?;
if chain.is_empty() {
if !first {
return Err(crate::Error::Validation(
"sparse relationship chain head is not first".to_owned(),
));
}
} else if first || previous != expected_previous {
return Err(crate::Error::Validation(format!(
"sparse relationship chain has an inconsistent previous link at {record_id}"
)));
}
chain.push(record_id);
expected_previous = Some(record_id);
current = next;
}
Ok(chain)
}
#[allow(dead_code)]
pub(super) fn sparse_dense_group_plan(&self, id: NodeId) -> Result<Vec<SparseDenseGroupPlan>> {
let node_id = self.node_neo4j_id(id)?;
let chain = self.sparse_relationship_chain(id)?;
let mut groups: BTreeMap<u32, SparseDenseGroupPlan> = BTreeMap::new();
for record_id in chain {
let record = self
.relationships
.records
.iter()
.find(|record| record.neo4j_id == record_id)
.ok_or_else(|| {
crate::Error::Validation(format!(
"sparse relationship chain references missing record {record_id}"
))
})?;
let group = groups
.entry(record.type_id)
.or_insert_with(|| SparseDenseGroupPlan {
type_id: record.type_id,
outgoing: Vec::new(),
incoming: Vec::new(),
loops: Vec::new(),
});
if record.start == node_id && record.end == node_id {
group.loops.push(record_id);
} else if record.start == node_id {
group.outgoing.push(record_id);
} else if record.end == node_id {
group.incoming.push(record_id);
} else {
return Err(crate::Error::Validation(format!(
"relationship {record_id} does not reference node {node_id}"
)));
}
}
Ok(groups.into_values().collect())
}
pub(super) fn connect_sparse_relationship_head(
&mut self,
node_id: NodeId,
relationship_id: u64,
) -> Result<(u64, RelationshipHeadPatch)> {
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
if node.dense {
return Err(crate::Error::UnsupportedWriteQuery(format!(
"creating a relationship on dense Neo4j node {} is not supported",
node.neo4j_id
)));
}
let neo4j_node_id = node.neo4j_id;
let old_head = node.next_relationship;
let patch = if let Some(old_head) = old_head {
let position = self
.relationships
.records
.iter()
.position(|record| record.neo4j_id == old_head)
.ok_or_else(|| {
crate::Error::Validation(format!(
"Neo4j node {neo4j_node_id} relationship head {old_head} is not loaded"
))
})?;
let record = &mut self.relationships.records[position];
let mut degree = None;
if record.start == neo4j_node_id {
if !record.first_in_start_chain {
return Err(crate::Error::Validation(format!(
"relationship {old_head} is not first in node {neo4j_node_id} start chain"
)));
}
degree = record.first_previous;
record.first_previous = Some(relationship_id);
record.first_in_start_chain = false;
}
if record.end == neo4j_node_id {
if !record.first_in_end_chain {
return Err(crate::Error::Validation(format!(
"relationship {old_head} is not first in node {neo4j_node_id} end chain"
)));
}
if degree.is_some() && degree != record.second_previous {
return Err(crate::Error::Validation(format!(
"loop relationship {old_head} has inconsistent chain degrees"
)));
}
degree = record.second_previous;
record.second_previous = Some(relationship_id);
record.first_in_end_chain = false;
}
let degree = degree.ok_or_else(|| {
crate::Error::Validation(format!(
"relationship {old_head} does not reference node {neo4j_node_id}"
))
})?;
let bytes = relationship::encode_catalog_record(record)
.map_err(crate::Error::UnsupportedWriteQuery)?;
Some((old_head, bytes, degree))
} else {
None
};
self.nodes.records[node_id].next_relationship = Some(relationship_id);
let (old_patch, old_degree) = match patch {
Some((record_id, bytes, degree)) => (Some((record_id, bytes)), degree),
None => (None, 0),
};
let new_degree = old_degree.checked_add(1).ok_or_else(|| {
crate::Error::UnsupportedWriteQuery("relationship degree overflow".to_owned())
})?;
Ok((new_degree, old_patch))
}
pub(super) fn connect_dense_relationship_head(
&mut self,
node_id: NodeId,
type_id: u32,
direction: u8,
relationship_id: u64,
) -> Result<DenseRelationshipHead> {
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
if !node.dense {
return Err(crate::Error::Validation(format!(
"Neo4j node {} is not dense",
node.neo4j_id
)));
}
if direction > 2 {
return Err(crate::Error::Validation(
"dense relationship direction must be 0, 1, or 2".to_owned(),
));
}
let neo4j_node_id = node.neo4j_id;
let group_ids = self
.relationship_groups
.by_node
.get(&neo4j_node_id)
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(format!(
"dense Neo4j node {neo4j_node_id} has no relationship group for type {type_id}"
))
})?;
let group_position = self
.relationship_groups
.records
.iter()
.position(|(id, group)| group_ids.contains(id) && group.type_id == type_id)
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(format!(
"creating a new relationship group on dense Neo4j node {neo4j_node_id} is not supported"
))
})?;
let (group_id, group) = &self.relationship_groups.records[group_position];
let group_id = *group_id;
let (old_head, external_degree) = match direction {
0 => (group.first_out, group.external_degrees_out),
1 => (group.first_in, group.external_degrees_in),
2 => (group.first_loop, group.external_degrees_loop),
_ => unreachable!(),
};
let (previous, relationship_patch, degree_delta, switch_to_external) =
if let Some(old_head) = old_head {
let old = relationship_record_mut(&mut self.relationships.records, old_head)?;
let (previous, _, first, _) = chain_state(old, neo4j_node_id)?;
if !first {
return Err(crate::Error::Validation(format!(
"dense relationship group {group_id} head {old_head} is not first in chain"
)));
}
set_chain_previous(old, neo4j_node_id, false, relationship_id)?;
let bytes = relationship::encode_catalog_record(old)
.map_err(crate::Error::UnsupportedWriteQuery)?;
let (previous, degree_delta, switch_to_external) = if external_degree {
(None, Some(1), false)
} else {
let count = previous
.ok_or_else(|| {
crate::Error::Validation(format!(
"dense relationship group {group_id} has no inline degree"
))
})?
.checked_add(1)
.ok_or_else(|| {
crate::Error::UnsupportedWriteQuery(
"dense relationship degree overflow".to_owned(),
)
})?;
if count > 10 {
let delta = i64::try_from(count).map_err(|_| {
crate::Error::UnsupportedWriteQuery(
"dense relationship degree exceeds i64".to_owned(),
)
})?;
(None, Some(delta), true)
} else {
(Some(count), None, false)
}
};
(
previous,
Some((old_head, bytes)),
degree_delta,
switch_to_external,
)
} else {
(
if external_degree { None } else { Some(1) },
None,
external_degree.then_some(1),
false,
)
};
let (_, group) = &mut self.relationship_groups.records[group_position];
match direction {
0 => group.first_out = Some(relationship_id),
1 => group.first_in = Some(relationship_id),
2 => group.first_loop = Some(relationship_id),
_ => unreachable!(),
}
if switch_to_external {
match direction {
0 => group.external_degrees_out = true,
1 => group.external_degrees_in = true,
2 => group.external_degrees_loop = true,
_ => unreachable!(),
}
}
let group_patch = relationship_group::encode_record(group)
.map_err(crate::Error::UnsupportedWriteQuery)?;
Ok(DenseRelationshipHead {
group_id,
previous,
next: old_head,
degree_delta,
group_patch,
relationship_patch,
})
}
pub(super) fn has_dense_relationship_group(
&self,
node_id: NodeId,
type_id: u32,
) -> Result<bool> {
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
Ok(self
.relationship_groups
.by_node
.get(&node.neo4j_id)
.into_iter()
.flatten()
.any(|group_id| {
self.relationship_groups
.records
.iter()
.any(|(id, group)| id == group_id && group.type_id == type_id)
}))
}
pub(super) fn create_dense_relationship_group(
&mut self,
node_id: NodeId,
type_id: u32,
group_id: u64,
) -> Result<DenseRelationshipGroupCreation> {
let (neo4j_node_id, node_head, dense) = self
.nodes
.records
.get(node_id)
.map(|node| (node.neo4j_id, node.next_relationship, node.dense))
.ok_or_else(|| crate::Error::Execution(format!("node id {node_id} does not exist")))?;
if !dense {
return Err(crate::Error::Validation(format!(
"Neo4j node {} is not dense",
neo4j_node_id
)));
}
if self.has_dense_relationship_group(node_id, type_id)? {
return Err(crate::Error::Validation(format!(
"dense relationship group type {type_id} already exists"
)));
}
let mut current = node_head;
let mut previous_position = None;
while let Some(current_id) = current {
let position = self
.relationship_groups
.records
.iter()
.position(|(id, _)| *id == current_id)
.ok_or_else(|| {
crate::Error::Validation("dense group chain is inconsistent".to_owned())
})?;
let group_type = self.relationship_groups.records[position].1.type_id;
if group_type > type_id {
break;
}
previous_position = Some(position);
current = self.relationship_groups.records[position].1.next;
}
let new_group = relationship_group::RelationshipGroupRecord {
type_id,
next: current,
first_out: None,
first_in: None,
first_loop: None,
owning_node: neo4j_node_id,
external_degrees_out: false,
external_degrees_in: false,
external_degrees_loop: false,
};
let group_patch = relationship_group::encode_record(&new_group)
.map_err(crate::Error::UnsupportedWriteQuery)?;
let previous_patch = if let Some(position) = previous_position {
let (previous_id, previous) = &mut self.relationship_groups.records[position];
previous.next = Some(group_id);
Some((
*previous_id,
relationship_group::encode_record(previous)
.map_err(crate::Error::UnsupportedWriteQuery)?,
))
} else {
self.nodes.records[node_id].next_relationship = Some(group_id);
None
};
self.relationship_groups.records.push((group_id, new_group));
self.relationship_groups
.by_node
.entry(neo4j_node_id)
.or_default()
.push(group_id);
Ok(DenseRelationshipGroupCreation {
group_patch,
previous_patch,
node_head: previous_position.is_none().then_some(group_id),
})
}
pub(in crate::neo4j_storage) fn insert_relationship(
&mut self,
record: relationship::RelationshipRecord,
relationship_type: String,
) -> Result<RelationshipId> {
let existing_id = self
.relationships
.records
.iter()
.position(|existing| existing.neo4j_id == record.neo4j_id);
if existing_id.is_some_and(|id| !self.deleted.relationships.contains(&id)) {
return Err(crate::Error::Validation(format!(
"Neo4j relationship record ID {} is already in use",
record.neo4j_id
)));
}
let start = self
.nodes
.records
.iter()
.position(|node| node.neo4j_id == record.start)
.ok_or_else(|| {
crate::Error::Execution("relationship start node does not exist".to_owned())
})?;
let end = self
.nodes
.records
.iter()
.position(|node| node.neo4j_id == record.end)
.ok_or_else(|| {
crate::Error::Execution("relationship end node does not exist".to_owned())
})?;
let id = existing_id.unwrap_or(self.query_relationships.len());
self.relationships
.outgoing
.entry(record.start)
.or_default()
.push(record.neo4j_id);
self.relationships
.incoming
.entry(record.end)
.or_default()
.push(record.neo4j_id);
self.outgoing[start].push(id);
self.incoming[end].push(id);
let query_relationship = Relationship {
id,
external_id: record.neo4j_id.to_string(),
start,
end,
r#type: relationship_type,
properties: crate::value::Properties::new(),
};
if existing_id.is_some() {
self.query_relationships[id] = query_relationship;
self.relationships.records[id] = record;
self.deleted.relationships.remove(&id);
} else {
self.query_relationships.push(query_relationship);
self.relationships.records.push(record);
}
Ok(id)
}
pub(super) fn delete_sparse_relationship(
&mut self,
id: RelationshipId,
) -> Result<DeletedRelationship> {
if self.deleted.relationships.contains(&id) {
return Err(crate::Error::Execution(format!(
"relationship id {id} does not exist"
)));
}
let query = self
.query_relationships
.get(id)
.ok_or_else(|| crate::Error::Execution(format!("relationship id {id} does not exist")))?
.clone();
let record_position = self
.relationships
.records
.iter()
.position(|record| record.neo4j_id.to_string() == query.external_id)
.ok_or_else(|| {
crate::Error::Validation("relationship catalog is inconsistent".to_owned())
})?;
let record = self.relationships.records[record_position].clone();
if record.start_node_dense || record.end_node_dense {
return self.delete_dense_relationship(id, query, record);
}
let mut record_patches = BTreeMap::new();
let endpoints = if record.start == record.end {
vec![record.start]
} else {
vec![record.start, record.end]
};
let mut node_heads = Vec::new();
for node_id in endpoints {
let (previous, next, first, degree) = chain_state(&record, node_id)?;
if first {
let node_position = self
.nodes
.records
.iter()
.position(|node| node.neo4j_id == node_id)
.ok_or_else(|| {
crate::Error::Validation("relationship endpoint is missing".to_owned())
})?;
if self.nodes.records[node_position].next_relationship != Some(record.neo4j_id) {
return Err(crate::Error::Validation(format!(
"relationship {} is first in node {node_id} chain but is not its head",
record.neo4j_id
)));
}
self.nodes.records[node_position].next_relationship = next;
node_heads.push((node_id, next));
if let Some(next_id) = next {
let next_record =
relationship_record_mut(&mut self.relationships.records, next_id)?;
set_chain_previous(
next_record,
node_id,
true,
degree.checked_sub(1).ok_or_else(|| {
crate::Error::Validation(
"relationship chain degree underflow".to_owned(),
)
})?,
)?;
record_patches.insert(
next_id,
relationship::encode_catalog_record(next_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
} else if degree != 1 {
return Err(crate::Error::Validation(format!(
"last relationship in node {node_id} chain has degree {degree}"
)));
}
} else {
let previous_id = previous.ok_or_else(|| {
crate::Error::Validation(
"non-head relationship has no previous link".to_owned(),
)
})?;
let previous_record =
relationship_record_mut(&mut self.relationships.records, previous_id)?;
set_chain_next(previous_record, node_id, next)?;
record_patches.insert(
previous_id,
relationship::encode_catalog_record(previous_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
if let Some(next_id) = next {
let next_record =
relationship_record_mut(&mut self.relationships.records, next_id)?;
set_chain_previous(next_record, node_id, false, previous_id)?;
record_patches.insert(
next_id,
relationship::encode_catalog_record(next_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
}
}
}
self.deleted.relationships.insert(id);
self.outgoing[query.start].retain(|relationship_id| *relationship_id != id);
self.incoming[query.end].retain(|relationship_id| *relationship_id != id);
if let Some(ids) = self.relationships.outgoing.get_mut(&record.start) {
ids.retain(|relationship_id| *relationship_id != record.neo4j_id);
}
if let Some(ids) = self.relationships.incoming.get_mut(&record.end) {
ids.retain(|relationship_id| *relationship_id != record.neo4j_id);
}
let mut unused_record = relationship::encode_catalog_record(&record)
.map_err(crate::Error::UnsupportedWriteQuery)?;
unused_record[0] &= !1;
record_patches.insert(record.neo4j_id, unused_record);
Ok(DeletedRelationship {
neo4j_id: record.neo4j_id,
start: query.start,
end: query.end,
type_id: record.type_id,
node_heads,
record_patches,
group_patches: BTreeMap::new(),
degree_deltas: Vec::new(),
freed_group_records: BTreeSet::new(),
})
}
fn delete_dense_relationship(
&mut self,
id: RelationshipId,
query: Relationship,
record: relationship::RelationshipRecord,
) -> Result<DeletedRelationship> {
let mut record_patches = BTreeMap::new();
let mut group_patches = BTreeMap::new();
let mut degree_deltas = Vec::new();
let mut node_heads = Vec::new();
let mut touched_groups = BTreeSet::new();
let endpoints = if record.start == record.end {
vec![(record.start, 2)]
} else {
let mut endpoints = Vec::new();
if record.start_node_dense {
endpoints.push((record.start, 0));
} else {
endpoints.push((record.start, 3));
}
if record.end_node_dense {
endpoints.push((record.end, 1));
} else {
endpoints.push((record.end, 3));
}
endpoints
};
for (node_id, direction) in endpoints {
if direction == 3 {
let (previous, next, first, degree) = chain_state(&record, node_id)?;
if first {
let node_position = self
.nodes
.records
.iter()
.position(|node| node.neo4j_id == node_id)
.ok_or_else(|| {
crate::Error::Validation("relationship endpoint is missing".to_owned())
})?;
if self.nodes.records[node_position].next_relationship != Some(record.neo4j_id)
{
return Err(crate::Error::Validation(
"sparse relationship head is inconsistent".to_owned(),
));
}
self.nodes.records[node_position].next_relationship = next;
node_heads.push((node_id, next));
if let Some(next_id) = next {
let next_record =
relationship_record_mut(&mut self.relationships.records, next_id)?;
set_chain_previous(
next_record,
node_id,
true,
degree.checked_sub(1).ok_or_else(|| {
crate::Error::Validation(
"sparse relationship degree underflow".to_owned(),
)
})?,
)?;
record_patches.insert(
next_id,
relationship::encode_catalog_record(next_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
}
} else {
let previous_id = previous.ok_or_else(|| {
crate::Error::Validation(
"sparse relationship has no previous link".to_owned(),
)
})?;
let previous_record =
relationship_record_mut(&mut self.relationships.records, previous_id)?;
set_chain_next(previous_record, node_id, next)?;
record_patches.insert(
previous_id,
relationship::encode_catalog_record(previous_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
if let Some(next_id) = next {
let next_record =
relationship_record_mut(&mut self.relationships.records, next_id)?;
set_chain_previous(next_record, node_id, false, previous_id)?;
record_patches.insert(
next_id,
relationship::encode_catalog_record(next_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
}
}
continue;
}
let group_position = self
.relationship_groups
.records
.iter()
.position(|(_, group)| {
group.owning_node == node_id && group.type_id == record.type_id
})
.ok_or_else(|| {
crate::Error::Validation("dense relationship group is missing".to_owned())
})?;
let (group_id, group) = &mut self.relationship_groups.records[group_position];
touched_groups.insert(*group_id);
let (head, external) = match direction {
0 => (group.first_out, group.external_degrees_out),
1 => (group.first_in, group.external_degrees_in),
_ => (group.first_loop, group.external_degrees_loop),
};
let (previous, next, first) = if record.start == node_id {
(
record.first_previous,
record.first_next,
record.first_in_start_chain,
)
} else if record.end == node_id {
(
record.second_previous,
record.second_next,
record.first_in_end_chain,
)
} else {
return Err(crate::Error::Validation(
"dense relationship endpoint is inconsistent".to_owned(),
));
};
let degree = previous.unwrap_or(0);
if !first {
let previous_id = previous.ok_or_else(|| {
crate::Error::Validation("dense relationship has no previous link".to_owned())
})?;
let previous_record =
relationship_record_mut(&mut self.relationships.records, previous_id)?;
set_chain_next(previous_record, node_id, next)?;
record_patches.insert(
previous_id,
relationship::encode_catalog_record(previous_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
if let Some(next_id) = next {
let next_record =
relationship_record_mut(&mut self.relationships.records, next_id)?;
set_chain_previous(next_record, node_id, false, previous_id)?;
record_patches.insert(
next_id,
relationship::encode_catalog_record(next_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
}
if external {
degree_deltas.push((*group_id, direction, -1));
}
continue;
}
if external {
degree_deltas.push((*group_id, direction, -1));
}
if head != Some(record.neo4j_id) {
return Err(crate::Error::Validation(
"dense relationship chain head does not match group".to_owned(),
));
}
let next = if direction == 0 {
record.first_next
} else if direction == 1 {
record.second_next
} else {
record.first_next
};
match direction {
0 => group.first_out = next,
1 => group.first_in = next,
_ => group.first_loop = next,
}
group_patches.insert(
*group_id,
relationship_group::encode_record(group)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
if let Some(next_id) = next {
let next_record =
relationship_record_mut(&mut self.relationships.records, next_id)?;
set_chain_previous(
next_record,
node_id,
true,
if external {
0
} else {
degree.checked_sub(1).ok_or_else(|| {
crate::Error::Validation(
"dense relationship degree underflow".to_owned(),
)
})?
},
)?;
record_patches.insert(
next_id,
relationship::encode_catalog_record(next_record)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
}
}
let mut freed_group_records = BTreeSet::new();
for group_id in touched_groups {
let Some(position) = self
.relationship_groups
.records
.iter()
.position(|(id, _)| *id == group_id)
else {
continue;
};
let (owner, next, empty) = {
let group = &self.relationship_groups.records[position].1;
(
group.owning_node,
group.next,
group.first_out.is_none()
&& group.first_in.is_none()
&& group.first_loop.is_none(),
)
};
if !empty {
continue;
}
let node_position = self
.nodes
.records
.iter()
.position(|node| node.neo4j_id == owner)
.ok_or_else(|| {
crate::Error::Validation("dense group owner is missing".to_owned())
})?;
if self.nodes.records[node_position].next_relationship == Some(group_id) {
self.nodes.records[node_position].next_relationship = next;
node_heads.push((owner, next));
} else {
let predecessor = self
.relationship_groups
.records
.iter_mut()
.find(|(_, group)| group.owning_node == owner && group.next == Some(group_id))
.ok_or_else(|| {
crate::Error::Validation("dense group predecessor is missing".to_owned())
})?;
predecessor.1.next = next;
group_patches.insert(
predecessor.0,
relationship_group::encode_record(&predecessor.1)
.map_err(crate::Error::UnsupportedWriteQuery)?,
);
}
let mut unused =
relationship_group::encode_record(&self.relationship_groups.records[position].1)
.map_err(crate::Error::UnsupportedWriteQuery)?;
unused[0] &= !1;
group_patches.insert(group_id, unused);
freed_group_records.insert(group_id);
if let Some(groups) = self.relationship_groups.by_node.get_mut(&owner) {
groups.retain(|id| *id != group_id);
}
}
self.deleted.relationships.insert(id);
self.outgoing[query.start].retain(|relationship_id| *relationship_id != id);
self.incoming[query.end].retain(|relationship_id| *relationship_id != id);
if let Some(ids) = self.relationships.outgoing.get_mut(&record.start) {
ids.retain(|relationship_id| *relationship_id != record.neo4j_id);
}
if let Some(ids) = self.relationships.incoming.get_mut(&record.end) {
ids.retain(|relationship_id| *relationship_id != record.neo4j_id);
}
let mut unused = relationship::encode_catalog_record(&record)
.map_err(crate::Error::UnsupportedWriteQuery)?;
unused[0] &= !1;
record_patches.insert(record.neo4j_id, unused);
Ok(DeletedRelationship {
neo4j_id: record.neo4j_id,
start: query.start,
end: query.end,
type_id: record.type_id,
node_heads,
record_patches,
group_patches,
degree_deltas,
freed_group_records,
})
}
pub(super) fn delete_isolated_node(&mut self, id: NodeId) -> Result<DeletedNode> {
if self.deleted.nodes.contains(&id) {
return Err(crate::Error::Execution(format!(
"node id {id} does not exist"
)));
}
if !self.outgoing_relationships(id).is_empty()
|| !self.incoming_relationships(id).is_empty()
{
return Err(crate::Error::Validation(
"DELETE node requires no attached relationships".to_owned(),
));
}
let node = self
.nodes
.records
.get(id)
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))?
.clone();
let label_ids = self.node_label_ids(id)?;
self.deleted.nodes.insert(id);
for label in &node.labels {
if let Some(ids) = self.nodes.label_index.get_mut(label) {
ids.retain(|node_id| *node_id != node.neo4j_id);
}
if let Some(ids) = self.label_index.get_mut(label) {
ids.retain(|node_id| *node_id != id);
}
}
Ok(DeletedNode {
neo4j_id: node.neo4j_id,
label_ids,
})
}
pub(super) fn node_label_ids(&self, id: NodeId) -> Result<Vec<u32>> {
let node = self
.nodes
.records
.get(id)
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))?;
node.labels
.iter()
.map(|label| {
self.tokens
.labels
.iter()
.find_map(|(token_id, name)| (name == label).then_some(*token_id))
.ok_or_else(|| {
crate::Error::Validation(format!(
"Neo4j node {} references unknown label `{label}`",
node.neo4j_id
))
})
})
.collect()
}
pub(super) fn insert_node_label(&mut self, id: NodeId, label: String) -> Result<()> {
let node = self
.nodes
.records
.get_mut(id)
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))?;
if node.labels.contains(&label) {
return Ok(());
}
let neo4j_id = node.neo4j_id;
node.labels.push(label.clone());
self.query_nodes[id].labels.push(label.clone());
self.nodes
.label_index
.entry(label.clone())
.or_default()
.push(neo4j_id);
self.label_index.entry(label).or_default().push(id);
Ok(())
}
pub(super) fn remove_node_label(&mut self, id: NodeId, label: &str) -> Result<()> {
let node = self
.nodes
.records
.get_mut(id)
.ok_or_else(|| crate::Error::Execution(format!("node id {id} does not exist")))?;
node.labels.retain(|node_label| node_label != label);
self.query_nodes[id]
.labels
.retain(|node_label| node_label != label);
if let Some(ids) = self.nodes.label_index.get_mut(label) {
ids.retain(|node_id| *node_id != node.neo4j_id);
}
if let Some(ids) = self.label_index.get_mut(label) {
ids.retain(|node_id| *node_id != id);
}
Ok(())
}
fn existing_property_key_id(&self, key: &str) -> Option<u32> {
self.tokens
.property_keys
.iter()
.find_map(|(id, name)| (name == key).then_some(*id))
}
fn node_dynamic_property(
&self,
node_id: NodeId,
key: &str,
) -> Result<Option<property::DynamicPropertyReference>> {
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
let Some(key_id) = self.existing_property_key_id(key) else {
return Ok(None);
};
Ok(self
.properties
.dynamic_reference_for_key(node.next_property, key_id))
}
fn relationship_dynamic_property(
&self,
relationship_id: RelationshipId,
key: &str,
) -> Result<Option<property::DynamicPropertyReference>> {
let relationship = self
.relationships
.records
.get(relationship_id)
.ok_or_else(|| {
crate::Error::Execution(format!("relationship id {relationship_id} does not exist"))
})?;
let Some(key_id) = self.existing_property_key_id(key) else {
return Ok(None);
};
Ok(self
.properties
.dynamic_reference_for_key(relationship.next_property, key_id))
}
pub(super) fn stage_node_property_update(
&mut self,
node_id: NodeId,
key: String,
value: crate::Value,
allocation_id: Option<u64>,
dynamic_string_id: Option<u64>,
dynamic_array_id: Option<u64>,
) -> Result<StagedPropertyUpdate> {
let key_id = self.property_key_id(&key)?;
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
let first_property = node.next_property;
let owner_record_id = node.neo4j_id;
let update = property::apply_fixed_size_update(
&mut self.properties,
first_property,
key_id,
&value,
allocation_id,
dynamic_string_id,
dynamic_array_id,
)
.map_err(crate::Error::UnsupportedWriteQuery)?;
if let Some(new_head) = update.new_head {
self.nodes.records[node_id].next_property = Some(new_head);
}
self.nodes.records[node_id]
.properties
.insert(key.clone(), value.clone());
self.query_nodes[node_id].properties.insert(key, value);
Ok(StagedPropertyUpdate {
property_records: update.records,
new_head: update.new_head,
owner_record_id,
})
}
pub(super) fn stage_relationship_property_update(
&mut self,
relationship_id: RelationshipId,
key: String,
value: crate::Value,
allocation_id: Option<u64>,
dynamic_string_id: Option<u64>,
dynamic_array_id: Option<u64>,
) -> Result<StagedPropertyUpdate> {
let key_id = self.property_key_id(&key)?;
let relationship = self
.relationships
.records
.get(relationship_id)
.ok_or_else(|| {
crate::Error::Execution(format!("relationship id {relationship_id} does not exist"))
})?;
let first_property = relationship.next_property;
let owner_record_id = relationship.neo4j_id;
let update = property::apply_fixed_size_update(
&mut self.properties,
first_property,
key_id,
&value,
allocation_id,
dynamic_string_id,
dynamic_array_id,
)
.map_err(crate::Error::UnsupportedWriteQuery)?;
if let Some(new_head) = update.new_head {
self.relationships.records[relationship_id].next_property = Some(new_head);
}
self.relationships.records[relationship_id]
.properties
.insert(key.clone(), value.clone());
self.query_relationships[relationship_id]
.properties
.insert(key, value);
Ok(StagedPropertyUpdate {
property_records: update.records,
new_head: update.new_head,
owner_record_id,
})
}
pub(in crate::neo4j_storage) fn stage_node_property_removal(
&mut self,
node_id: NodeId,
key: &str,
) -> Result<Option<StagedPropertyRemoval>> {
let node =
self.nodes.records.get(node_id).ok_or_else(|| {
crate::Error::Execution(format!("node id {node_id} does not exist"))
})?;
let first_property = node.next_property;
let owner_record_id = node.neo4j_id;
let Some(key_id) = self.existing_property_key_id(key) else {
return Ok(None);
};
let update = property::apply_removal(&mut self.properties, first_property, key_id)
.map_err(crate::Error::UnsupportedWriteQuery)?;
let Some(update) = update else {
return Ok(None);
};
if let Some(new_head) = update.owner_head {
self.nodes.records[node_id].next_property = new_head;
}
self.nodes.records[node_id].properties.remove(key);
self.query_nodes[node_id].properties.remove(key);
Ok(Some(StagedPropertyRemoval {
property_records: update.records,
owner_record_id,
owner_head: update.owner_head,
freed_record_id: update.freed_record_id,
dynamic: update.dynamic,
}))
}
pub(in crate::neo4j_storage) fn stage_relationship_property_removal(
&mut self,
relationship_id: RelationshipId,
key: &str,
) -> Result<Option<StagedPropertyRemoval>> {
let relationship = self
.relationships
.records
.get(relationship_id)
.ok_or_else(|| {
crate::Error::Execution(format!("relationship id {relationship_id} does not exist"))
})?;
let first_property = relationship.next_property;
let owner_record_id = relationship.neo4j_id;
let Some(key_id) = self.existing_property_key_id(key) else {
return Ok(None);
};
let update = property::apply_removal(&mut self.properties, first_property, key_id)
.map_err(crate::Error::UnsupportedWriteQuery)?;
let Some(update) = update else {
return Ok(None);
};
if let Some(new_head) = update.owner_head {
self.relationships.records[relationship_id].next_property = new_head;
}
self.relationships.records[relationship_id]
.properties
.remove(key);
self.query_relationships[relationship_id]
.properties
.remove(key);
Ok(Some(StagedPropertyRemoval {
property_records: update.records,
owner_record_id,
owner_head: update.owner_head,
freed_record_id: update.freed_record_id,
dynamic: update.dynamic,
}))
}
pub fn node_count(&self) -> usize {
self.nodes.records.len()
}
pub fn nodes(&self) -> &[Node] {
&self.query_nodes
}
pub fn node_ids(&self) -> Vec<NodeId> {
(0..self.query_nodes.len())
.filter(|id| !self.deleted.nodes.contains(id))
.collect()
}
pub fn relationships(&self) -> &[Relationship] {
&self.query_relationships
}
pub fn relationship_ids(&self) -> Vec<RelationshipId> {
(0..self.query_relationships.len())
.filter(|id| !self.deleted.relationships.contains(id))
.collect()
}
pub fn node(&self, id: NodeId) -> Option<&Node> {
(!self.deleted.nodes.contains(&id))
.then(|| self.query_nodes.get(id))
.flatten()
}
pub fn relationship(&self, id: RelationshipId) -> Option<&Relationship> {
(!self.deleted.relationships.contains(&id))
.then(|| self.query_relationships.get(id))
.flatten()
}
pub fn node_by_external_id(&self, external_id: &str) -> Option<NodeId> {
self.query_nodes
.iter()
.find(|node| node.external_id == external_id && !self.deleted.nodes.contains(&node.id))
.map(|node| node.id)
}
pub fn relationship_by_external_id(&self, external_id: &str) -> Option<RelationshipId> {
self.query_relationships
.iter()
.find(|relationship| {
relationship.external_id == external_id
&& !self.deleted.relationships.contains(&relationship.id)
})
.map(|relationship| relationship.id)
}
pub fn neo4j_node_ids_with_label(&self, label: &str) -> &[u64] {
self.nodes
.label_index
.get(label)
.map(Vec::as_slice)
.unwrap_or(&[])
}
pub fn relationship_count(&self) -> usize {
self.relationships.records.len()
}
pub fn neo4j_relationship_ids_from(&self, node_id: u64) -> &[u64] {
self.relationships
.outgoing
.get(&node_id)
.map(Vec::as_slice)
.unwrap_or(&[])
}
pub fn outgoing_relationships(&self, node_id: NodeId) -> &[RelationshipId] {
self.outgoing.get(node_id).map(Vec::as_slice).unwrap_or(&[])
}
pub fn incoming_relationships(&self, node_id: NodeId) -> &[RelationshipId] {
self.incoming.get(node_id).map(Vec::as_slice).unwrap_or(&[])
}
fn node_property_type(&self, node_id: NodeId, property_key: &str) -> Option<String> {
let node = self.nodes.records.get(node_id)?;
let key_id = self.existing_property_key_id(property_key)?;
self.properties
.type_name_for_key(node.next_property, key_id)
}
fn relationship_property_type(
&self,
relationship_id: RelationshipId,
property_key: &str,
) -> Option<String> {
let relationship = self.relationships.records.get(relationship_id)?;
let key_id = self.existing_property_key_id(property_key)?;
self.properties
.type_name_for_key(relationship.next_property, key_id)
}
pub fn nodes_with_label(&self, label: &str) -> &[NodeId] {
self.label_index
.get(label)
.map(Vec::as_slice)
.unwrap_or(&[])
}
pub fn neo4j_relationship_ids_to(&self, node_id: u64) -> &[u64] {
self.relationships
.incoming
.get(&node_id)
.map(Vec::as_slice)
.unwrap_or(&[])
}
}
type QueryView = (
Vec<Node>,
Vec<Relationship>,
Vec<Vec<RelationshipId>>,
Vec<Vec<RelationshipId>>,
BTreeMap<String, Vec<NodeId>>,
);
fn build_query_view(
nodes: &node::NodeCatalog,
relationships: &relationship::RelationshipCatalog,
relationship_types: &BTreeMap<u32, String>,
) -> Result<QueryView> {
let node_ids = nodes
.records
.iter()
.enumerate()
.map(|(id, node)| (node.neo4j_id, id))
.collect::<BTreeMap<_, _>>();
let query_nodes = nodes
.records
.iter()
.enumerate()
.map(|(id, node)| Node {
id,
external_id: node.neo4j_id.to_string(),
labels: node.labels.clone(),
properties: node.properties.clone(),
})
.collect::<Vec<_>>();
let mut outgoing = vec![Vec::new(); query_nodes.len()];
let mut incoming = vec![Vec::new(); query_nodes.len()];
let mut query_relationships = Vec::with_capacity(relationships.records.len());
for (id, relationship) in relationships.records.iter().enumerate() {
let start = node_ids[&relationship.start];
let end = node_ids[&relationship.end];
let relationship_type = relationship_types[&relationship.type_id].clone();
query_relationships.push(Relationship {
id,
external_id: relationship.neo4j_id.to_string(),
start,
end,
r#type: relationship_type,
properties: relationship.properties.clone(),
});
outgoing[start].push(id);
incoming[end].push(id);
}
let mut label_index: BTreeMap<String, Vec<NodeId>> = BTreeMap::new();
for node in &query_nodes {
for label in &node.labels {
label_index.entry(label.clone()).or_default().push(node.id);
}
}
Ok((
query_nodes,
query_relationships,
outgoing,
incoming,
label_index,
))
}
impl StorageInterface for Neo4jStorage {
fn database_metadata(&self) -> Option<&DatabaseMetadata> {
Some(&self.database_metadata)
}
fn schema_metadata(&self) -> Option<&SchemaMetadata> {
Some(&self.schema)
}
fn node_ids(&self) -> Vec<NodeId> {
Neo4jStorage::node_ids(self)
}
fn relationship_ids(&self) -> Vec<RelationshipId> {
Neo4jStorage::relationship_ids(self)
}
fn node(&self, id: NodeId) -> Option<&Node> {
Neo4jStorage::node(self, id)
}
fn relationship(&self, id: RelationshipId) -> Option<&Relationship> {
Neo4jStorage::relationship(self, id)
}
fn outgoing_relationships(&self, id: NodeId) -> &[RelationshipId] {
self.outgoing.get(id).map(Vec::as_slice).unwrap_or(&[])
}
fn incoming_relationships(&self, id: NodeId) -> &[RelationshipId] {
self.incoming.get(id).map(Vec::as_slice).unwrap_or(&[])
}
fn nodes_with_label(&self, label: &str) -> &[NodeId] {
self.label_index
.get(label)
.map(Vec::as_slice)
.unwrap_or(&[])
}
fn node_by_external_id(&self, external_id: &str) -> Option<NodeId> {
Neo4jStorage::node_by_external_id(self, external_id)
}
fn relationship_by_external_id(&self, external_id: &str) -> Option<RelationshipId> {
Neo4jStorage::relationship_by_external_id(self, external_id)
}
fn label_tokens(&self) -> Vec<String> {
self.public_label_token_names()
}
fn relationship_type_tokens(&self) -> Vec<String> {
self.public_relationship_type_token_names()
}
fn property_key_tokens(&self) -> Vec<String> {
self.public_property_key_token_names()
}
fn node_property_type(&self, id: NodeId, property_key: &str) -> Option<String> {
Neo4jStorage::node_property_type(self, id, property_key)
}
fn relationship_property_type(&self, id: RelationshipId, property_key: &str) -> Option<String> {
Neo4jStorage::relationship_property_type(self, id, property_key)
}
}
fn public_token_names(tokens: &BTreeMap<u32, String>, internal: &BTreeSet<u32>) -> Vec<String> {
tokens
.iter()
.filter(|(id, _)| !internal.contains(id))
.map(|(_, name)| name.clone())
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::storage_interface::{TransactionState, TransactionalStorage, WritableStorage};
use crate::value::{Properties, Value};
use std::fs;
fn copy_directory(source: &Path, target: &Path) {
fs::create_dir_all(target).unwrap();
for entry in fs::read_dir(source).unwrap() {
let entry = entry.unwrap();
let source_path = entry.path();
let target_path = target.join(entry.file_name());
if entry.file_type().unwrap().is_dir() {
copy_directory(&source_path, &target_path);
} else {
fs::copy(source_path, target_path).unwrap();
}
}
}
#[test]
fn builds_compact_query_ids_for_sparse_neo4j_records() {
let nodes = node::NodeCatalog {
records: vec![
node::NodeRecord {
neo4j_id: 4,
next_property: None,
next_relationship: None,
dense: false,
labels: vec!["Person".to_owned()],
properties: Properties::new(),
},
node::NodeRecord {
neo4j_id: 19,
next_property: None,
next_relationship: None,
dense: true,
labels: vec!["Person".to_owned(), "Admin".to_owned()],
properties: Properties::new(),
},
],
label_index: BTreeMap::new(),
};
let relationships = relationship::RelationshipCatalog {
records: vec![relationship::RelationshipRecord {
neo4j_id: 27,
start: 19,
end: 4,
type_id: 3,
next_property: None,
first_previous: None,
first_next: None,
second_previous: None,
second_next: None,
first_in_start_chain: true,
first_in_end_chain: true,
start_node_dense: false,
end_node_dense: false,
properties: Properties::new(),
}],
outgoing: BTreeMap::new(),
incoming: BTreeMap::new(),
};
let relationship_types = BTreeMap::from([(3, "KNOWS".to_owned())]);
let (query_nodes, query_relationships, outgoing, incoming, label_index) =
build_query_view(&nodes, &relationships, &relationship_types).unwrap();
assert_eq!(query_nodes[0].external_id, "4");
assert_eq!(query_nodes[1].external_id, "19");
assert_eq!(query_relationships[0].external_id, "27");
assert_eq!(query_relationships[0].start, 1);
assert_eq!(query_relationships[0].end, 0);
assert_eq!(query_relationships[0].r#type, "KNOWS");
assert_eq!(outgoing, vec![vec![], vec![0]]);
assert_eq!(incoming, vec![vec![0], vec![]]);
assert_eq!(label_index["Person"], vec![0, 1]);
assert_eq!(label_index["Admin"], vec![1]);
}
#[test]
fn graph_opens_empty_store_and_rejects_writes() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
assert!(!Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j(&database).unwrap();
let result = graph.query("MATCH (n) RETURN n", BTreeMap::new()).unwrap();
assert!(result.rows.is_empty());
let error = graph.query("CREATE (n)", BTreeMap::new()).unwrap_err();
assert!(error.to_string().contains("read-only"));
drop(graph);
let mut writable = crate::Graph::open_neo4j_writable(&database).unwrap();
writable
.query("MATCH (n) SET n.marker = 1", BTreeMap::new())
.unwrap();
assert!(!database.join(".littlegraph-write-journal").exists());
assert!(!database.join(".littlegraph-write-journal.tmp").exists());
writable
.query("CREATE (n) RETURN n", BTreeMap::new())
.unwrap();
assert!(matches!(
writable.query(
"MATCH (n) SET n.marker = 2, n.bad = $missing",
BTreeMap::new()
),
Err(crate::Error::Validation(_))
));
let result = writable
.query("MATCH (n) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(result.rows.len(), 1);
assert_eq!(result.rows[0].values, [Value::Null]);
}
#[test]
fn read_only_open_rejects_a_pending_journal_until_writable_recovery() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let temporary_journal = database.join(".littlegraph-write-journal.tmp");
fs::write(&temporary_journal, b"partial journal").unwrap();
assert!(matches!(
crate::Graph::open_neo4j(&database),
Err(crate::Error::Neo4jStore(
crate::Neo4jStoreError::InvalidJournal { .. }
))
));
assert!(temporary_journal.exists());
drop(crate::Graph::open_neo4j_writable(&database).unwrap());
assert!(!temporary_journal.exists());
crate::Graph::open_neo4j(&database).unwrap();
}
#[test]
fn database_lock_allows_readers_or_in_process_mvcc_writers_but_not_both() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let first_reader = Neo4jStorage::open(&database).unwrap();
let second_reader = crate::Graph::open_neo4j(&database).unwrap();
assert!(matches!(
crate::Graph::open_neo4j_writable(&database),
Err(crate::Error::Neo4jStore(
crate::Neo4jStoreError::DatabaseLocked { .. }
))
));
drop(first_reader);
drop(second_reader);
let writer = crate::Graph::open_neo4j_writable(&database).unwrap();
let second_writer = crate::Graph::open_neo4j_writable(&database).unwrap();
assert!(matches!(
Neo4jStorage::open(&database),
Err(crate::Error::Neo4jStore(
crate::Neo4jStoreError::DatabaseLocked { .. }
))
));
drop(writer);
drop(second_writer);
Neo4jStorage::open(&database).unwrap();
}
#[test]
fn mvcc_transactions_keep_snapshots_detect_write_conflicts_and_retry() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut first = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut second = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut first_tx = first.transaction().unwrap();
let mut second_tx = second.transaction().unwrap();
first_tx
.query("CREATE (:FirstCommit)", BTreeMap::new())
.unwrap();
second_tx
.query("CREATE (:ConflictingCommit)", BTreeMap::new())
.unwrap();
first_tx.commit().unwrap();
assert!(second_tx
.query("MATCH (n:FirstCommit) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
assert!(matches!(
second_tx.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::Conflict
))
));
let mut retry = second.transaction().unwrap();
assert_eq!(
retry
.query("MATCH (n:FirstCommit) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
retry
.query("CREATE (:SecondCommit)", BTreeMap::new())
.unwrap();
retry.commit().unwrap();
let result = first.query("MATCH (n) RETURN n", BTreeMap::new()).unwrap();
assert_eq!(result.rows.len(), 2);
}
#[test]
fn mvcc_coordinates_alias_paths_to_the_same_database() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut direct = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut aliased = crate::Graph::open_neo4j_writable(database.join(".")).unwrap();
let mut direct_tx = direct.transaction().unwrap();
let mut aliased_tx = aliased.transaction().unwrap();
direct_tx
.query("CREATE (:DirectPath)", BTreeMap::new())
.unwrap();
aliased_tx
.query("CREATE (:AliasPath)", BTreeMap::new())
.unwrap();
direct_tx.commit().unwrap();
assert!(matches!(
aliased_tx.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::Conflict
))
));
assert!(aliased
.query("MATCH (n:AliasPath) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
assert_eq!(
aliased
.query("MATCH (n:DirectPath) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
}
#[test]
fn run_transaction_replays_the_closure_after_a_conflict() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut blocker_graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut retry_graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut blocker = Some(blocker_graph.transaction().unwrap());
blocker
.as_mut()
.unwrap()
.query("CREATE (:Blocker)", BTreeMap::new())
.unwrap();
let mut attempts = 0;
retry_graph
.run_transaction(1, |transaction| {
attempts += 1;
transaction
.query("CREATE (:Retried)", BTreeMap::new())
.unwrap();
if attempts == 1 {
blocker.take().unwrap().commit()?;
}
Ok(())
})
.unwrap();
assert_eq!(attempts, 2);
let result = retry_graph
.query("MATCH (n:Retried) RETURN n", BTreeMap::new())
.unwrap();
assert_eq!(result.rows.len(), 1);
}
#[test]
fn mvcc_read_transaction_remains_stable_while_another_session_commits() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut reader = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut writer = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut read_tx = reader.transaction().unwrap();
assert!(read_tx
.query("MATCH (n:Later) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
writer.query("CREATE (:Later)", BTreeMap::new()).unwrap();
assert!(read_tx
.query("MATCH (n:Later) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
read_tx.commit().unwrap();
assert_eq!(
reader
.query("MATCH (n:Later) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
}
#[test]
fn mvcc_coordinates_transactions_running_on_different_threads() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let barrier = Arc::new(std::sync::Barrier::new(2));
let (committed_sender, committed_receiver) = std::sync::mpsc::channel();
std::thread::scope(|scope| {
let first_database = database.clone();
let first_barrier = Arc::clone(&barrier);
scope.spawn(move || {
let mut graph = crate::Graph::open_neo4j_writable(first_database).unwrap();
let mut transaction = graph.transaction().unwrap();
transaction
.query("CREATE (:ThreadWinner)", BTreeMap::new())
.unwrap();
first_barrier.wait();
transaction.commit().unwrap();
committed_sender.send(()).unwrap();
});
let second_database = database.clone();
let second_barrier = Arc::clone(&barrier);
scope.spawn(move || {
let mut graph = crate::Graph::open_neo4j_writable(second_database).unwrap();
let mut transaction = graph.transaction().unwrap();
transaction
.query("CREATE (:ThreadConflict)", BTreeMap::new())
.unwrap();
second_barrier.wait();
committed_receiver.recv().unwrap();
assert!(matches!(
transaction.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::Conflict
))
));
});
});
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
assert_eq!(
graph
.query("MATCH (n:ThreadWinner) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
assert!(graph
.query("MATCH (n:ThreadConflict) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
drop(graph);
let mut reopened = crate::Graph::open_neo4j_writable(&database).unwrap();
reopened
.query("CREATE (:AfterCoordinatorDrop)", BTreeMap::new())
.unwrap();
assert_eq!(
reopened
.query("MATCH (n:AfterCoordinatorDrop) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
}
fn run_threaded_mvcc_counter_stress(workers: usize, increments_per_worker: usize) {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut setup = crate::Graph::open_neo4j_writable(&database).unwrap();
setup
.query("CREATE (:MvccStressCounter {value: 0})", BTreeMap::new())
.unwrap();
drop(setup);
let barrier = Arc::new(std::sync::Barrier::new(workers + 1));
std::thread::scope(|scope| {
for _ in 0..workers {
let database = database.clone();
let barrier = Arc::clone(&barrier);
scope.spawn(move || {
let mut graph = crate::Graph::open_neo4j_writable(database).unwrap();
barrier.wait();
for _ in 0..increments_per_worker {
graph
.run_transaction(256, |transaction| {
transaction.query(
"MATCH (n:MvccStressCounter) SET n.value = n.value + 1",
BTreeMap::new(),
)?;
Ok(())
})
.unwrap();
}
});
}
barrier.wait();
});
let mut verifier = crate::Graph::open_neo4j_writable(&database).unwrap();
let result = verifier
.query(
"MATCH (n:MvccStressCounter) RETURN n.value",
BTreeMap::new(),
)
.unwrap();
assert_eq!(
result.rows[0].values,
[Value::Integer((workers * increments_per_worker) as i64)]
);
}
#[test]
fn threaded_mvcc_counter_stress_does_not_lose_updates() {
run_threaded_mvcc_counter_stress(4, 12);
}
#[test]
#[ignore = "long-running MVCC stress test"]
fn threaded_mvcc_counter_stress_long_running() {
let workers = std::env::var("LITTLEGRAPH_MVCC_STRESS_WORKERS")
.ok()
.and_then(|value| value.parse().ok())
.unwrap_or(4);
let increments = std::env::var("LITTLEGRAPH_MVCC_STRESS_INCREMENTS")
.ok()
.and_then(|value| value.parse().ok())
.unwrap_or(500);
run_threaded_mvcc_counter_stress(workers, increments);
}
#[test]
fn read_only_open_does_not_create_a_lock_file_in_an_invalid_directory() {
let directory = tempfile::tempdir().unwrap();
fs::write(directory.path().join("unrelated"), b"preserve me").unwrap();
assert!(Neo4jStorage::open(directory.path()).is_err());
assert!(!directory.path().join("database_lock").exists());
assert_eq!(
fs::read(directory.path().join("unrelated")).unwrap(),
b"preserve me"
);
}
#[test]
fn graph_transactions_commit_rollback_drop_and_reject_use_after_failure() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut read_only = crate::Graph::open_neo4j(&database).unwrap();
let mut transaction = read_only.transaction().unwrap();
assert!(transaction
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
assert!(matches!(
transaction.query("CREATE (n)", BTreeMap::new()),
Err(crate::Error::UnsupportedWriteQuery(_))
));
assert!(matches!(
transaction.query("MATCH (n) RETURN n", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
transaction.rollback().unwrap();
drop(read_only);
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
{
let mut transaction = graph.transaction().unwrap();
assert!(transaction
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
transaction.commit().unwrap();
}
assert!(!database.join(".littlegraph-write-journal").exists());
assert!(!database.join(".littlegraph-write-journal.tmp").exists());
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("CREATE (n {marker: 1})", BTreeMap::new())
.unwrap();
let visible = transaction
.query("MATCH (n) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(visible.rows[0].values, [Value::Integer(1)]);
transaction.commit().unwrap();
}
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("MATCH (n) SET n.marker = 2", BTreeMap::new())
.unwrap();
transaction.rollback().unwrap();
}
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("MATCH (n) SET n.marker = 3", BTreeMap::new())
.unwrap();
}
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("MATCH (n) SET n.marker = 4", BTreeMap::new())
.unwrap();
assert!(matches!(
transaction.query("not valid Cypher", BTreeMap::new()),
Err(crate::Error::Parse(_))
));
assert!(matches!(
transaction.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
}
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("MATCH (n) SET n.marker = 5", BTreeMap::new())
.unwrap();
assert!(matches!(
transaction.query("MATCH (n) SET n.marker = $missing", BTreeMap::new()),
Err(crate::Error::Validation(_))
));
assert!(matches!(
transaction.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
}
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("MATCH (n) SET n.marker = 6", BTreeMap::new())
.unwrap();
let params = BTreeMap::from([("bad".to_owned(), Value::Map(BTreeMap::new()))]);
assert!(matches!(
transaction.query("MATCH (n) SET n.bad = $bad", params),
Err(crate::Error::UnsupportedWriteQuery(_))
));
assert!(matches!(
transaction.query("MATCH (n) RETURN n", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
transaction.rollback().unwrap();
}
let visible = graph
.query("MATCH (n) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(visible.rows[0].values, [Value::Integer(1)]);
drop(graph);
let mut reopened = crate::Graph::open_neo4j(&database).unwrap();
let durable = reopened
.query("MATCH (n) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(durable.rows[0].values, [Value::Integer(1)]);
}
#[test]
fn transaction_savepoints_restore_workspace_and_allow_recovery() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
graph
.query("CREATE (:Endpoint {slot: 0})", BTreeMap::new())
.unwrap();
graph
.query("CREATE (:Endpoint {slot: 1})", BTreeMap::new())
.unwrap();
graph
.query("CREATE (:SavepointBase {marker: 1})", BTreeMap::new())
.unwrap();
let stale_savepoint;
{
let mut transaction = graph.transaction().unwrap();
let root = transaction.savepoint().unwrap();
let dynamic_params = BTreeMap::from([
("note".to_owned(), Value::String("x".repeat(400))),
(
"numbers".to_owned(),
Value::List((0..160).map(Value::Integer).collect()),
),
]);
transaction
.query(
"CREATE (:TransientSavepoint:S1:S2:S3:S4:S5:S6:S7 {note: $note, numbers: $numbers})",
dynamic_params.clone(),
)
.unwrap();
transaction
.query(
"MATCH (a:Endpoint {slot: 0}), (b:Endpoint {slot: 1}) CREATE (a)-[:TRANSIENT_SAVEPOINT {note: $note}]->(b)",
dynamic_params.clone(),
)
.unwrap();
let before_transient_delete = transaction.savepoint().unwrap();
transaction
.query(
"MATCH ()-[r:TRANSIENT_SAVEPOINT]->() DELETE r",
BTreeMap::new(),
)
.unwrap();
transaction
.query("MATCH (n:TransientSavepoint) DELETE n", BTreeMap::new())
.unwrap();
transaction.rollback_to(before_transient_delete).unwrap();
assert_eq!(
transaction
.query(
"MATCH ()-[r:TRANSIENT_SAVEPOINT]->() RETURN r",
BTreeMap::new(),
)
.unwrap()
.rows
.len(),
1
);
assert!(matches!(
transaction.query("not valid Cypher", BTreeMap::new()),
Err(crate::Error::Parse(_))
));
transaction.rollback_to(root).unwrap();
assert!(transaction
.query("MATCH (n:TransientSavepoint) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
assert!(transaction
.query(
"MATCH ()-[r:TRANSIENT_SAVEPOINT]->() RETURN r",
BTreeMap::new(),
)
.unwrap()
.rows
.is_empty());
let before_delete = transaction.savepoint().unwrap();
transaction
.query("MATCH (n:SavepointBase) DELETE n", BTreeMap::new())
.unwrap();
transaction.rollback_to(before_delete).unwrap();
let restored_after_delete = transaction
.query("MATCH (n:SavepointBase) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(restored_after_delete.rows[0].values, [Value::Integer(1)]);
let before_partial_set = transaction.savepoint().unwrap();
let error = transaction
.query(
"MATCH (n:SavepointBase) SET n.marker = 2, n.bad = $bad",
BTreeMap::from([("bad".to_owned(), Value::Map(BTreeMap::new()))]),
)
.unwrap_err();
assert!(matches!(error, crate::Error::UnsupportedWriteQuery(_)));
transaction.rollback_to(before_partial_set).unwrap();
let restored = transaction
.query("MATCH (n:SavepointBase) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(restored.rows[0].values, [Value::Integer(1)]);
transaction
.query("MATCH (n:SavepointBase) SET n.marker = 3", BTreeMap::new())
.unwrap();
transaction
.query(
"CREATE (:KeptSavepoint:K1:K2:K3:K4:K5:K6:K7 {note: $note, numbers: $numbers})",
dynamic_params,
)
.unwrap();
let released_older = transaction.savepoint().unwrap();
transaction
.query("CREATE (:RetainedSavepoint)", BTreeMap::new())
.unwrap();
let retained = transaction.savepoint().unwrap();
transaction
.query("CREATE (:ReleasedFutureSavepoint)", BTreeMap::new())
.unwrap();
transaction.release_savepoint(released_older).unwrap();
transaction.rollback_to(retained).unwrap();
assert_eq!(
transaction
.query("MATCH (n:RetainedSavepoint) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
assert!(transaction
.query(
"MATCH (n:ReleasedFutureSavepoint) RETURN n",
BTreeMap::new(),
)
.unwrap()
.rows
.is_empty());
let before_future = transaction.savepoint().unwrap();
transaction
.query("CREATE (:FutureSavepoint)", BTreeMap::new())
.unwrap();
let future = transaction.savepoint().unwrap();
transaction
.query("CREATE (:LaterSavepoint)", BTreeMap::new())
.unwrap();
transaction.rollback_to(before_future).unwrap();
assert!(matches!(
transaction.rollback_to(future),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::InvalidSavepoint
))
));
transaction.release_savepoint(before_future).unwrap();
assert!(matches!(
transaction.rollback_to(before_future),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::InvalidSavepoint
))
));
stale_savepoint = root;
transaction.commit().unwrap();
}
{
let mut transaction = graph.transaction().unwrap();
let _ = transaction.savepoint().unwrap();
transaction
.query("CREATE (:ExplicitSavepointRollback)", BTreeMap::new())
.unwrap();
transaction.rollback().unwrap();
}
{
let mut transaction = graph.transaction().unwrap();
let _ = transaction.savepoint().unwrap();
transaction
.query("CREATE (:DroppedSavepointTransaction)", BTreeMap::new())
.unwrap();
}
{
let mut transaction = graph.transaction().unwrap();
assert!(matches!(
transaction.rollback_to(stale_savepoint),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::InvalidSavepoint
))
));
transaction.rollback().unwrap();
}
drop(graph);
let mut reopened = crate::Graph::open_neo4j(&database).unwrap();
let durable = reopened
.query("MATCH (n:SavepointBase) RETURN n.marker", BTreeMap::new())
.unwrap();
assert_eq!(durable.rows[0].values, [Value::Integer(3)]);
assert_eq!(
reopened
.query("MATCH (n:KeptSavepoint) RETURN n", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
for label in [
"TransientSavepoint",
"FutureSavepoint",
"LaterSavepoint",
"ReleasedFutureSavepoint",
"ExplicitSavepointRollback",
"DroppedSavepointTransaction",
] {
assert!(reopened
.query(&format!("MATCH (n:{label}) RETURN n"), BTreeMap::new())
.unwrap()
.rows
.is_empty());
}
}
#[test]
fn first_sparse_relationship_degree_fields_reopen_as_chain_counts() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
graph
.query("CREATE (:DegreeEndpoint {slot: 0})", BTreeMap::new())
.unwrap();
graph
.query("CREATE (:DegreeEndpoint {slot: 1})", BTreeMap::new())
.unwrap();
graph
.query(
"MATCH (a:DegreeEndpoint {slot: 0}), (b:DegreeEndpoint {slot: 1}) CREATE (a)-[:DEGREE_FIELD]->(b)",
BTreeMap::new(),
)
.unwrap();
drop(graph);
let mut reopened = crate::Graph::open_neo4j(&database).unwrap();
assert_eq!(
reopened
.query("MATCH ()-[r:DEGREE_FIELD]->() RETURN r", BTreeMap::new())
.unwrap()
.rows
.len(),
1
);
}
#[test]
fn read_only_transaction_can_recover_to_a_savepoint() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j(&database).unwrap();
let mut transaction = graph.transaction().unwrap();
let savepoint = transaction.savepoint().unwrap();
assert!(matches!(
transaction.query("CREATE (:Rejected)", BTreeMap::new()),
Err(crate::Error::UnsupportedWriteQuery(_))
));
transaction.rollback_to(savepoint).unwrap();
assert!(transaction
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
transaction.commit().unwrap();
}
#[test]
fn savepoints_recover_from_parse_plan_and_execution_errors() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut transaction = graph.transaction().unwrap();
for query in [
"not valid Cypher",
"MATCH (n) RETURN other",
"RETURN 1 / 0 AS invalid",
] {
let savepoint = transaction.savepoint().unwrap();
assert!(transaction.query(query, BTreeMap::new()).is_err());
assert!(matches!(
transaction.savepoint(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
transaction.rollback_to(savepoint).unwrap();
transaction.release_savepoint(savepoint).unwrap();
transaction
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap();
}
transaction.commit().unwrap();
}
#[test]
fn savepoint_token_errors_and_release_preserve_transaction_state() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let foreign = {
let mut transaction = graph.transaction().unwrap();
let savepoint = transaction.savepoint().unwrap();
transaction.rollback().unwrap();
savepoint
};
let mut transaction = graph.transaction().unwrap();
let recoverable = transaction.savepoint().unwrap();
assert!(matches!(
transaction.rollback_to(foreign),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::InvalidSavepoint
))
));
transaction
.query("CREATE (:PreservedAfterInvalidToken)", BTreeMap::new())
.unwrap();
let released = transaction.savepoint().unwrap();
transaction.release_savepoint(released).unwrap();
assert!(transaction
.query("not valid Cypher", BTreeMap::new())
.is_err());
assert!(matches!(
transaction.rollback_to(released),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::InvalidSavepoint
))
));
assert!(matches!(
transaction.query("MATCH (n) RETURN n", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
transaction.rollback_to(recoverable).unwrap();
assert!(transaction
.query(
"MATCH (n:PreservedAfterInvalidToken) RETURN n",
BTreeMap::new(),
)
.unwrap()
.rows
.is_empty());
transaction.commit().unwrap();
}
#[test]
fn transaction_options_enforce_timeout_and_cancellation() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
{
let options = crate::TransactionOptions {
timeout: Some(std::time::Duration::ZERO),
..crate::TransactionOptions::default()
};
let mut transaction = graph.transaction_with_options(options).unwrap();
assert!(matches!(
transaction.query("CREATE (:TimedOut)", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::TimedOut
))
));
transaction.rollback().unwrap();
}
{
let token = crate::CancellationToken::new();
let options = crate::TransactionOptions {
cancellation_token: Some(token.clone()),
..crate::TransactionOptions::default()
};
let mut transaction = graph.transaction_with_options(options).unwrap();
transaction
.query("CREATE (:CancelledBeforeCommit)", BTreeMap::new())
.unwrap();
std::thread::spawn(move || token.cancel()).join().unwrap();
assert!(matches!(
transaction.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::Cancelled
))
));
}
{
let mut transaction = graph.transaction().unwrap();
transaction.cancel();
assert!(matches!(
transaction.query("MATCH (n) RETURN n", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::Cancelled
))
));
transaction.rollback().unwrap();
}
{
let mut transaction = graph
.transaction_with_options(crate::TransactionOptions {
max_records: Some(0),
..crate::TransactionOptions::default()
})
.unwrap();
assert!(matches!(
transaction.query("CREATE (:OverBudget)", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
transaction.cancel();
assert!(matches!(
transaction.query("MATCH (n) RETURN n", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
transaction.rollback().unwrap();
}
let visible = graph.query("MATCH (n) RETURN n", BTreeMap::new()).unwrap();
assert!(visible.rows.is_empty());
}
#[test]
fn transaction_workspace_limits_are_recoverable_at_a_savepoint() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
{
let mut transaction = graph
.transaction_with_options(crate::TransactionOptions {
max_records: Some(0),
..crate::TransactionOptions::default()
})
.unwrap();
let root = transaction.savepoint().unwrap();
assert!(matches!(
transaction.query("CREATE (:OverBudget)", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
assert!(matches!(
transaction.query("MATCH (n) RETURN n", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
transaction.rollback_to(root).unwrap();
assert!(transaction
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
transaction.commit().unwrap();
}
{
assert!(matches!(
graph.transaction_with_options(crate::TransactionOptions {
max_workspace_bytes: Some(0),
..crate::TransactionOptions::default()
}),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
assert!(graph
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
}
let mut transaction = graph
.transaction_with_options(crate::TransactionOptions {
max_workspace_bytes: Some(usize::MAX),
max_records: Some(usize::MAX),
..crate::TransactionOptions::default()
})
.unwrap();
transaction
.query("CREATE (:WithinBudget)", BTreeMap::new())
.unwrap();
transaction.commit().unwrap();
}
#[test]
fn transaction_workspace_spills_and_preserves_savepoint_semantics() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
{
let mut transaction = graph
.transaction_with_options(crate::TransactionOptions {
spill_threshold_bytes: Some(0),
max_spill_bytes: Some(1024 * 1024),
..crate::TransactionOptions::default()
})
.unwrap();
transaction
.query("CREATE (:Spilled {value: 1})", BTreeMap::new())
.unwrap();
let savepoint = transaction.savepoint().unwrap();
transaction
.query("MATCH (n:Spilled) SET n.value = 2", BTreeMap::new())
.unwrap();
transaction.rollback_to(savepoint).unwrap();
let result = transaction
.query("MATCH (n:Spilled) RETURN n.value", BTreeMap::new())
.unwrap();
assert_eq!(result.rows[0].values, vec![Value::Integer(1)]);
transaction.commit().unwrap();
}
let result = graph
.query("MATCH (n:Spilled) RETURN n.value", BTreeMap::new())
.unwrap();
assert_eq!(result.rows[0].values, vec![Value::Integer(1)]);
let spill_directory = database.join(".littlegraph-transactions");
assert_eq!(std::fs::read_dir(spill_directory).unwrap().count(), 0);
let mut transaction = graph
.transaction_with_options(crate::TransactionOptions {
spill_threshold_bytes: Some(0),
max_spill_bytes: Some(8),
..crate::TransactionOptions::default()
})
.unwrap();
assert!(matches!(
transaction.query("CREATE (:TooLarge)", BTreeMap::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
transaction.rollback().unwrap();
}
#[test]
fn transaction_journal_limit_fails_before_publication_and_preserves_storage() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut transaction = graph
.transaction_with_options(crate::TransactionOptions {
max_journal_bytes: Some(0),
..crate::TransactionOptions::default()
})
.unwrap();
transaction
.query("CREATE (:OverJournalBudget)", BTreeMap::new())
.unwrap();
assert!(matches!(
transaction.commit(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::ResourceLimit
))
));
assert!(!database.join(".littlegraph-write-journal").exists());
assert!(!database.join(".littlegraph-write-journal.tmp").exists());
assert!(graph
.query("MATCH (n) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
graph
.query("CREATE (:AfterJournalLimit)", BTreeMap::new())
.unwrap();
}
#[test]
fn transaction_can_delete_new_and_reused_nodes_and_relationships() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
graph
.query("CREATE (:Endpoint {slot: 0})", BTreeMap::new())
.unwrap();
graph
.query("CREATE (:Endpoint {slot: 1})", BTreeMap::new())
.unwrap();
{
let mut transaction = graph.transaction().unwrap();
let params = BTreeMap::from([
("note".to_owned(), Value::String("x".repeat(400))),
(
"numbers".to_owned(),
Value::List((0..160).map(Value::Integer).collect()),
),
]);
transaction
.query(
"CREATE (:TransientAppend:Append1:Append2:Append3:Append4:Append5:Append6:Append7 {note: $note, numbers: $numbers})",
params.clone(),
)
.unwrap();
transaction
.query(
"MATCH (a:Endpoint {slot: 0}), (b:Endpoint {slot: 1}) CREATE (a)-[:TRANSIENT_APPEND {note: $note, numbers: $numbers}]->(b)",
params,
)
.unwrap();
transaction
.query(
"MATCH ()-[r:TRANSIENT_APPEND]->() DELETE r",
BTreeMap::new(),
)
.unwrap();
transaction
.query("MATCH (n:TransientAppend) DELETE n", BTreeMap::new())
.unwrap();
transaction.commit().unwrap();
}
graph
.query("CREATE (:ReusableNode)", BTreeMap::new())
.unwrap();
graph
.query("MATCH (n:ReusableNode) DELETE n", BTreeMap::new())
.unwrap();
graph
.query(
"MATCH (a:Endpoint {slot: 0}), (b:Endpoint {slot: 1}) CREATE (a)-[:REUSABLE_REL]->(b)",
BTreeMap::new(),
)
.unwrap();
graph
.query("MATCH ()-[r:REUSABLE_REL]->() DELETE r", BTreeMap::new())
.unwrap();
{
let mut transaction = graph.transaction().unwrap();
transaction
.query("CREATE (:TransientReuse)", BTreeMap::new())
.unwrap();
transaction
.query(
"MATCH (a:Endpoint {slot: 0}), (b:Endpoint {slot: 1}) CREATE (a)-[:TRANSIENT_REUSE]->(b)",
BTreeMap::new(),
)
.unwrap();
transaction
.query("MATCH ()-[r:TRANSIENT_REUSE]->() DELETE r", BTreeMap::new())
.unwrap();
transaction
.query("MATCH (n:TransientReuse) DELETE n", BTreeMap::new())
.unwrap();
transaction.commit().unwrap();
}
for query in [
"MATCH (n:TransientAppend) RETURN n",
"MATCH (n:TransientReuse) RETURN n",
"MATCH ()-[r:TRANSIENT_APPEND]->() RETURN r",
"MATCH ()-[r:TRANSIENT_REUSE]->() RETURN r",
] {
assert!(graph.query(query, BTreeMap::new()).unwrap().rows.is_empty());
}
drop(graph);
let mut reopened = crate::Graph::open_neo4j(&database).unwrap();
assert_eq!(
reopened
.query("MATCH (n:Endpoint) RETURN n.slot", BTreeMap::new())
.unwrap()
.rows
.len(),
2
);
assert!(reopened
.query("MATCH ()-[r]->() RETURN r", BTreeMap::new())
.unwrap()
.rows
.is_empty());
}
#[test]
fn transaction_can_shrink_dynamic_records_allocated_by_an_earlier_statement() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let short_text = Value::String("s".repeat(40));
let long_text = Value::String("l".repeat(250));
let short_numbers = Value::List((0..8).map(Value::Integer).collect());
let long_numbers = Value::List((0..80).map(Value::Integer).collect());
graph
.query(
"CREATE (:DynamicBase {key: 1, text: $text, numbers: $numbers})",
BTreeMap::from([
("text".to_owned(), short_text.clone()),
("numbers".to_owned(), short_numbers.clone()),
]),
)
.unwrap();
{
let mut transaction = graph.transaction().unwrap();
transaction
.query(
"MATCH (n:DynamicBase) SET n.text = $text",
BTreeMap::from([("text".to_owned(), long_text.clone())]),
)
.unwrap();
transaction
.query(
"MATCH (n:DynamicBase) SET n.numbers = $numbers",
BTreeMap::from([("numbers".to_owned(), long_numbers.clone())]),
)
.unwrap();
transaction
.query(
"MATCH (n:DynamicBase) SET n.text = $text",
BTreeMap::from([("text".to_owned(), short_text.clone())]),
)
.unwrap();
transaction
.query(
"MATCH (n:DynamicBase) SET n.numbers = $numbers",
BTreeMap::from([("numbers".to_owned(), short_numbers.clone())]),
)
.unwrap();
transaction
.query(
"CREATE (:DynamicNew:New1:New2:New3:New4:New5:New6:New7 {text: $text})",
BTreeMap::from([("text".to_owned(), long_text)]),
)
.unwrap();
transaction
.query(
"MATCH (n:DynamicNew) SET n.text = $text",
BTreeMap::from([("text".to_owned(), Value::String("inline".to_owned()))]),
)
.unwrap();
transaction
.query("MATCH (n:DynamicNew) REMOVE n:New7", BTreeMap::new())
.unwrap();
transaction.commit().unwrap();
}
drop(graph);
let mut reopened = crate::Graph::open_neo4j(&database).unwrap();
let base = reopened
.query(
"MATCH (n:DynamicBase) RETURN n.text, n.numbers",
BTreeMap::new(),
)
.unwrap();
assert_eq!(
base.rows[0].values,
[short_text.clone(), short_numbers.clone()]
);
let new = reopened
.query("MATCH (n:DynamicNew) RETURN n.text", BTreeMap::new())
.unwrap();
assert_eq!(new.rows[0].values, [Value::String("inline".to_owned())]);
assert!(reopened
.query("MATCH (n:DynamicNew:New7) RETURN n", BTreeMap::new())
.unwrap()
.rows
.is_empty());
}
#[test]
fn writable_transaction_state_errors_are_explicit_and_recoverable() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut storage = Neo4jWritableStorage::open(&database).unwrap();
assert!(matches!(
storage.commit_transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::NotActive
))
));
assert!(matches!(
storage.rollback_transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::NotActive
))
));
assert!(matches!(
storage.create_node(Vec::new(), Properties::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::NotActive
))
));
storage.begin_transaction().unwrap();
assert_eq!(storage.transaction_state(), Some(TransactionState::Active));
assert!(matches!(
storage.begin_transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::AlreadyActive
))
));
storage.mark_transaction_failed();
assert_eq!(storage.transaction_state(), Some(TransactionState::Failed));
assert!(matches!(
storage.create_node(Vec::new(), Properties::new()),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
assert!(matches!(
storage.commit_transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::RollbackOnly
))
));
storage.rollback_transaction().unwrap();
assert_eq!(storage.transaction_state(), None);
storage.begin_transaction().unwrap();
storage.commit_transaction().unwrap();
assert_eq!(storage.transaction_state(), None);
}
#[test]
fn failed_commit_reload_poisons_storage_and_preserves_both_errors() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut storage = Neo4jWritableStorage::open(&database).unwrap();
storage.begin_transaction().unwrap();
storage.create_node(Vec::new(), Properties::new()).unwrap();
fs::remove_file(database.join("neostore.nodestore.db")).unwrap();
let error = storage.commit_transaction().unwrap_err();
let crate::Error::Neo4jStore(crate::Neo4jStoreError::CommitRecovery {
commit_error,
recovery_error,
..
}) = error
else {
panic!("expected commit recovery error");
};
assert!(matches!(
*commit_error,
crate::Error::Neo4jStore(crate::Neo4jStoreError::Read { .. })
| crate::Error::Neo4jStore(crate::Neo4jStoreError::MissingFile { .. })
));
assert!(matches!(
*recovery_error,
crate::Error::Neo4jStore(crate::Neo4jStoreError::MissingFile { .. })
| crate::Error::Neo4jStore(crate::Neo4jStoreError::Read { .. })
));
assert!(matches!(
storage.begin_transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::StoragePoisoned
))
));
}
#[test]
fn committed_transaction_stays_successful_when_cache_refresh_fails() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut storage = Neo4jWritableStorage::open(&database).unwrap();
storage.begin_transaction().unwrap();
let node_id = storage.create_node(Vec::new(), Properties::new()).unwrap();
writable::fail_next_post_commit_refresh();
storage.commit_transaction().unwrap();
assert!(storage.node(node_id).is_some());
assert!(matches!(
storage.begin_transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::StoragePoisoned
))
));
assert!(!database.join(".littlegraph-write-journal").exists());
drop(storage);
let reopened = Neo4jStorage::open(&database).unwrap();
assert!(reopened.node(node_id).is_some());
}
#[test]
fn fatal_commit_recovery_poisons_graph_until_reopen() {
let home = tempfile::tempdir().unwrap();
let database = home.path().join("data/databases/neo4j");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
let mut graph = crate::Graph::open_neo4j_writable(&database).unwrap();
let mut transaction = graph.transaction().unwrap();
transaction
.query("CREATE (n:ShouldRollback)", BTreeMap::new())
.unwrap();
fs::write(
database.join(".littlegraph-write-journal.tmp"),
b"conflicting artifact",
)
.unwrap();
assert!(matches!(
transaction.commit(),
Err(crate::Error::Neo4jStore(
crate::Neo4jStoreError::CommitRecovery { .. }
))
));
assert!(matches!(
graph.transaction(),
Err(crate::Error::Transaction(
crate::TransactionErrorKind::StoragePoisoned
))
));
drop(graph);
let mut reopened = crate::Graph::open_neo4j_writable(&database).unwrap();
assert!(!database.join(".littlegraph-write-journal.tmp").exists());
let result = reopened
.query("MATCH (n:ShouldRollback) RETURN n", BTreeMap::new())
.unwrap();
assert!(result.rows.is_empty());
}
#[test]
fn initializes_a_missing_directory_but_preserves_a_non_empty_directory() {
let parent = tempfile::tempdir().unwrap();
let database = parent.path().join("new-database");
assert!(Neo4jStorage::initialize_if_empty(&database).unwrap());
assert!(database.join("neostore").is_file());
let existing = parent.path().join("existing");
fs::create_dir_all(&existing).unwrap();
fs::write(existing.join("marker"), b"keep").unwrap();
assert!(!Neo4jStorage::initialize_if_empty(&existing).unwrap());
assert_eq!(fs::read(existing.join("marker")).unwrap(), b"keep");
assert!(!existing.join("neostore").exists());
}
#[test]
#[ignore = "requires NEO4J_REAL_FIXTURE generated by tools/neo4j-fixture-generator"]
fn offline_fixed_size_property_update_reopens_in_littlegraph() {
let source = std::env::var("NEO4J_REAL_FIXTURE").unwrap();
let directory = tempfile::tempdir().unwrap();
let database = directory.path().join("neo4j");
copy_directory(Path::new(&source), &database);
let storage = Neo4jStorage::open(&database).unwrap();
let alice_id = storage
.query_nodes
.iter()
.position(|node| node.properties.get("name") == Some(&Value::String("Alice".into())))
.unwrap();
let (record_id, bytes) = storage
.prepare_node_property_update(alice_id, "age", &Value::Integer(43))
.unwrap();
let property_path = database.join("neostore.propertystore.db");
let layout = page::PageLayout::new(&property_path, storage.format, 41).unwrap();
let mut writer = page::RecordWriter::open(&property_path, "property", layout).unwrap();
writer.write(record_id, &bytes).unwrap();
writer.sync_all().unwrap();
drop(writer);
drop(storage);
let reopened = Neo4jStorage::open(&database).unwrap();
let alice = reopened
.query_nodes
.iter()
.find(|node| node.properties.get("name") == Some(&Value::String("Alice".into())))
.unwrap();
assert_eq!(alice.properties.get("age"), Some(&Value::Integer(43)));
}
}