Add methods to write props to GraphWriter

Author: fabubaker

db4-storage/src/api/graph.rs

@@ -1,12 +1,10 @@
 use std::fmt::Debug;
 use std::path::Path;
 use crate::error::StorageError;
-use raphtory_core::entities::properties::props::MetadataError;
-use raphtory_core::entities::properties::tprop::IllegalPropType;
-use raphtory_core::storage::timeindex::TimeIndexEntry;
 use raphtory_core::entities::properties::tprop::TPropCell;
 use raphtory_api::core::entities::properties::prop::Prop;
-
+use parking_lot::RwLockWriteGuard;
+use crate::segments::graph::segment::MemGraphSegment;
 
 pub trait GraphSegmentOps: Send + Sync + Debug + 'static
 where
@@ -19,6 +17,8 @@ where
     fn load(path: impl AsRef<Path>) -> Result<Self, StorageError>;
 
     fn entry(&self) -> Self::Entry<'_>;
+
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemGraphSegment>;
 }
 
 /// Methods for reading graph properties and metadata from storage.
@@ -27,17 +27,3 @@ pub trait GraphEntryOps<'a>: Send + Sync + 'a {
 
     fn get_metadata(&self, prop_id: usize) -> Option<Prop>;
 }
-
-/// Methods for writing graph properties and metadata to storage.
-pub trait GraphEntryMutOps: Send + Sync {
-    fn add_prop(
-        &self,
-        t: TimeIndexEntry,
-        prop_id: usize,
-        prop: Prop,
-    ) -> Result<(), IllegalPropType>;
-
-    fn add_metadata(&self, prop_id: usize, prop: Prop) -> Result<(), MetadataError>;
-
-    fn update_metadata(&self, prop_id: usize, prop: Prop);
-}

db4-storage/src/api/nodes.rs

@@ -70,6 +70,7 @@ pub trait NodeSegmentOps: Send + Sync + std::fmt::Debug + 'static {
     fn segment_id(&self) -> usize;
 
     fn head_arc(&self) -> ArcRwLockReadGuard<parking_lot::RawRwLock, MemNodeSegment>;
+
     fn head(&self) -> RwLockReadGuard<'_, MemNodeSegment>;
 
     fn head_mut(&self) -> RwLockWriteGuard<'_, MemNodeSegment>;

db4-storage/src/pages/graph_page/writer.rs

@@ -1,16 +1,30 @@
 use crate::{
-    LocalPOS, api::graph::GraphSegmentOps, error::StorageError, pages::layer_counter::GraphStats,
     segments::graph::segment::MemGraphSegment,
 };
-use std::ops::DerefMut;
+use raphtory_core::storage::timeindex::TimeIndexEntry;
+use raphtory_api::core::entities::properties::prop::Prop;
+use parking_lot::RwLockWriteGuard;
 
-pub struct GraphWriter<'a, MP: DerefMut<Target = MemGraphSegment> + 'a, GS: GraphSegmentOps> {
-    pub page: &'a GS,
-    pub writer: MP,
+/// Provides mutable access to a graph segment. Holds an exclusive write lock
+/// on the in-memory segment for the duration of its lifetime.
+pub struct GraphWriter<'a> {
+    pub mem_segment: RwLockWriteGuard<'a, MemGraphSegment>,
 }
 
-impl<'a, MP: DerefMut<Target = MemGraphSegment> + 'a, GS: GraphSegmentOps> GraphWriter<'a, MP, GS> {
-    pub fn new(page: &'a GS, writer: MP) -> Self {
-        Self { page, writer }
+impl<'a> GraphWriter<'a> {
+    pub fn new(mem_segment: RwLockWriteGuard<'a, MemGraphSegment>) -> Self {
+        Self { mem_segment }
+    }
+
+    pub fn add_properties(&mut self, t: TimeIndexEntry, props: impl IntoIterator<Item = (usize, Prop)>) {
+        self.mem_segment.add_properties(t, props)
+    }
+
+    pub fn add_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>) {
+        self.mem_segment.add_metadata(props)
+    }
+
+    pub fn update_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>) {
+        self.mem_segment.update_metadata(props)
     }
 }

db4-storage/src/pages/graph_store.rs

@@ -2,6 +2,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use crate::api::graph::GraphSegmentOps;
 use crate::error::StorageError;
+use crate::pages::graph_page::writer::GraphWriter;
 use crate::persist::strategy::Config;
 use raphtory_core::entities::properties::graph_meta::GraphMeta;
 
@@ -63,4 +64,10 @@ impl<GS: GraphSegmentOps, EXT: Config> GraphStorageInner<GS, EXT> {
     pub fn graph_entry(&self) -> GS::Entry<'_> {
         self.page.entry()
     }
+
+    pub fn writer(&self) -> GraphWriter<'_> {
+        let head = self.page.head_mut();
+
+        GraphWriter::new(head)
+    }
 }

db4-storage/src/pages/locked/nodes.rs

@@ -63,6 +63,7 @@ impl<'a, EXT, NS: NodeSegmentOps<Extension = EXT>> LockedNodePage<'a, NS> {
         self.layer_counter.get(layer_id);
     }
 }
+
 pub struct WriteLockedNodePages<'a, NS> {
     writers: Vec<LockedNodePage<'a, NS>>,
 }

db4-storage/src/segments/graph/entry.rs

@@ -6,31 +6,25 @@ use parking_lot::RwLockReadGuard;
 
 /// A borrowed view enabling read operations on an in-memory graph segment.
 pub struct MemGraphEntry<'a> {
-    mem: RwLockReadGuard<'a, MemGraphSegment>,
+    mem_segment: RwLockReadGuard<'a, MemGraphSegment>,
 }
 
 impl<'a> MemGraphEntry<'a> {
-    pub fn new(mem: RwLockReadGuard<'a, MemGraphSegment>) -> Self {
-        Self { mem }
+    pub fn new(mem_segment: RwLockReadGuard<'a, MemGraphSegment>) -> Self {
+        Self { mem_segment }
     }
 }
 
 impl<'a> GraphEntryOps<'a> for MemGraphEntry<'a> {
     fn get_temporal_prop(&self, prop_id: usize) -> Option<TPropCell<'_>> {
-        let row = 0; // GraphSegment has only one row
+        let layer = &self.mem_segment.layers().get(MemGraphSegment::LAYER).expect("GraphSegment has no layers");
 
-        // TODO: handle multiple layers
-        let layer = &self.mem.layers().get(0).expect("GraphSegment has no layers");
-
-        layer.t_prop(row, prop_id)
+        layer.t_prop(MemGraphSegment::ROW, prop_id)
     }
 
     fn get_metadata(&self, prop_id: usize) -> Option<Prop> {
-        let row = 0; // GraphSegment has only one row
-
-        // TODO: handle multiple layers
-        let layer = &self.mem.layers().get(0).expect("GraphSegment has no layers");
+        let layer = &self.mem_segment.layers().get(MemGraphSegment::LAYER).expect("GraphSegment has no layers");
 
-        layer.c_prop(row, prop_id)
+        layer.c_prop(MemGraphSegment::ROW, prop_id)
     }
 }

db4-storage/src/segments/graph/mod.rs

@@ -9,6 +9,7 @@ use crate::api::graph::GraphSegmentOps;
 use crate::error::StorageError;
 use crate::segments::graph::segment::MemGraphSegment;
 use crate::segments::graph::entry::MemGraphEntry;
+use parking_lot::RwLockWriteGuard;
 
 /// `GraphSegmentView` manages graph temporal properties and graph metadata
 /// (constant properties). Reads / writes are always served from the in-memory segment.
@@ -38,6 +39,11 @@ impl GraphSegmentOps for GraphSegmentView {
 
     fn entry(&self) -> Self::Entry<'_> {
         let head = self.head.read();
+
         MemGraphEntry::new(head)
     }
+
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemGraphSegment> {
+        self.head.write()
+    }
 }

db4-storage/src/segments/graph/segment.rs

@@ -7,6 +7,8 @@ use crate::segments::graph::entry::MemGraphEntry;
 use crate::segments::{HasRow, SegmentContainer};
 use parking_lot::RwLock;
 use raphtory_api::core::entities::properties::meta::Meta;
+use raphtory_core::storage::timeindex::TimeIndexEntry;
+use raphtory_api::core::entities::properties::prop::Prop;
 
 /// In-memory segment that contains graph temporal properties and graph metadata.
 #[derive(Debug)]
@@ -32,6 +34,12 @@ impl HasRow for GraphSegmentEntry {
 }
 
 impl MemGraphSegment {
+    /// Graph segments only have a single row.
+    pub const ROW: usize = 0;
+
+    /// Graph segments are currently only written to a single layer.
+    pub const LAYER: usize = 0;
+
     pub fn new() -> Self {
         // Technically, these aren't used since there is always only one graph segment.
         let segment_id = 0;
@@ -46,4 +54,22 @@ impl MemGraphSegment {
     pub fn layers(&self) -> &[SegmentContainer<GraphSegmentEntry>] {
         &self.layers
     }
+
+    pub fn add_properties(&mut self, t: TimeIndexEntry, props: impl IntoIterator<Item = (usize, Prop)>) {
+        let layer = &mut self.layers[Self::LAYER];
+
+        layer.properties_mut().get_mut_entry(Self::ROW).append_t_props(t, props);
+    }
+
+    pub fn add_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>) {
+        let layer = &mut self.layers[Self::LAYER];
+
+        layer.properties_mut().get_mut_entry(Self::ROW).append_const_props(props);
+    }
+
+    pub fn update_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>) {
+        let layer = &mut self.layers[Self::LAYER];
+
+        layer.properties_mut().get_mut_entry(Self::ROW).append_const_props(props);
+    }
 }

raphtory/src/db/api/mutation/property_addition_ops.rs

@@ -18,6 +18,7 @@ pub trait PropertyAdditionOps:
     ) -> Result<(), GraphError>;
 
     fn add_metadata<PI: CollectProperties>(&self, props: PI) -> Result<(), GraphError>;
+
     fn update_metadata<PI: CollectProperties>(&self, props: PI) -> Result<(), GraphError>;
 }