replace GraphMeta with Meta and other changes to Graph properties

Author: fabianmurariu

db4-graph/src/lib.rs

@@ -19,12 +19,16 @@ use raphtory_core::{
     storage::timeindex::TimeIndexEntry,
 };
 use storage::{
-    api::graph::GraphSegmentOps, error::StorageError, pages::{
+    api::graph::GraphPropOps,
+    error::StorageError,
+    pages::{
         layer_counter::GraphStats,
         locked::{edges::WriteLockedEdgePages, nodes::WriteLockedNodePages},
-    }, persist::strategy::{Config, PersistentStrategy},
-    resolver::GIDResolverOps, wal::{GraphWal, TransactionID, Wal},
-    Extension, GIDResolver, Layer, ReadLockedLayer, WalImpl, ES, GS, NS
+    },
+    persist::strategy::{Config, PersistentStrategy},
+    resolver::GIDResolverOps,
+    wal::{GraphWal, TransactionID, Wal},
+    Extension, GIDResolver, Layer, ReadLockedLayer, WalImpl, ES, GS, NS,
 };
 use tempfile::TempDir;
 
@@ -127,17 +131,23 @@ impl<EXT: PersistentStrategy<NS = NS<EXT>, ES = ES<EXT>>> TemporalGraph<EXT> {
     pub fn new(ext: EXT) -> Result<Self, StorageError> {
         let node_meta = Meta::new_for_nodes();
         let edge_meta = Meta::new_for_edges();
-        let graph_meta = GraphMeta::new();
+        let graph_meta = Meta::new_for_graph();
 
         Self::new_with_meta(None, node_meta, edge_meta, graph_meta, ext)
     }
 
     pub fn new_with_path(path: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
         let node_meta = Meta::new_for_nodes();
         let edge_meta = Meta::new_for_edges();
-        let graph_meta = GraphMeta::new();
+        let graph_meta = Meta::new_for_graph();
 
-        Self::new_with_meta(Some(path.as_ref().into()), node_meta, edge_meta, graph_meta, ext)
+        Self::new_with_meta(
+            Some(path.as_ref().into()),
+            node_meta,
+            edge_meta,
+            graph_meta,
+            ext,
+        )
     }
 
     pub fn load_from_path(path: impl AsRef<Path>) -> Result<Self, StorageError> {
@@ -164,7 +174,7 @@ impl<EXT: PersistentStrategy<NS = NS<EXT>, ES = ES<EXT>>> TemporalGraph<EXT> {
         graph_dir: Option<GraphDir>,
         node_meta: Meta,
         edge_meta: Meta,
-        graph_meta: GraphMeta,
+        graph_meta: Meta,
         ext: EXT,
     ) -> Result<Self, StorageError> {
         let mut graph_dir = graph_dir;
@@ -238,10 +248,6 @@ impl<EXT: PersistentStrategy<NS = NS<EXT>, ES = ES<EXT>>> TemporalGraph<EXT> {
         }
     }
 
-    pub fn graph_entry(&self) -> <GS as GraphSegmentOps>::Entry<'_> {
-        self.storage().graph().graph_entry()
-    }
-
     #[inline]
     pub fn internal_num_nodes(&self) -> usize {
         self.logical_to_physical.len()
@@ -264,7 +270,7 @@ impl<EXT: PersistentStrategy<NS = NS<EXT>, ES = ES<EXT>>> TemporalGraph<EXT> {
         self.storage().node_meta()
     }
 
-    pub fn graph_meta(&self) -> &GraphMeta {
+    pub fn graph_meta(&self) -> &Meta {
         self.storage.graph_meta()
     }
 

db4-storage/src/api/graph.rs

@@ -1,24 +1,32 @@
 use crate::error::StorageError;
-use crate::segments::graph::segment::MemGraphSegment;
+use crate::segments::graph::segment::MemGraphProps;
 use parking_lot::{RwLockReadGuard, RwLockWriteGuard};
+use raphtory_api::core::entities::properties::meta::Meta;
 use raphtory_api::core::entities::properties::prop::Prop;
 use raphtory_api::core::entities::properties::tprop::TPropOps;
 use std::fmt::Debug;
 use std::path::Path;
+use std::sync::Arc;
 
-pub trait GraphSegmentOps: Send + Sync + Debug + 'static
+pub trait GraphPropOps: Send + Sync + Debug + 'static
 where
     Self: Sized,
 {
+    type Extension;
+
     type Entry<'a>: GraphEntryOps<'a>;
 
-    fn new(path: Option<&Path>) -> Self;
+    fn new(meta: Arc<Meta>, path: Option<&Path>, ext: Self::Extension) -> Self;
 
-    fn load(path: impl AsRef<Path>) -> Result<Self, StorageError>;
+    fn load(
+        meta: Arc<Meta>,
+        path: impl AsRef<Path>,
+        ext: Self::Extension,
+    ) -> Result<Self, StorageError>;
 
-    fn head(&self) -> RwLockReadGuard<'_, MemGraphSegment>;
+    fn head(&self) -> RwLockReadGuard<'_, MemGraphProps>;
 
-    fn head_mut(&self) -> RwLockWriteGuard<'_, MemGraphSegment>;
+    fn head_mut(&self) -> RwLockWriteGuard<'_, MemGraphProps>;
 
     fn entry(&self) -> Self::Entry<'_>;
 

db4-storage/src/lib.rs

@@ -17,11 +17,15 @@ use crate::{
     persist::strategy::NoOpStrategy,
     resolver::mapping_resolver::MappingResolver,
     segments::{
-        edge::entry::{MemEdgeEntry, MemEdgeRef},
-        edge::segment::EdgeSegmentView,
+        edge::{
+            entry::{MemEdgeEntry, MemEdgeRef},
+            segment::EdgeSegmentView,
+        },
         graph::entry::MemGraphEntry,
-        node::entry::{MemNodeEntry, MemNodeRef},
-        node::segment::NodeSegmentView,
+        node::{
+            entry::{MemNodeEntry, MemNodeRef},
+            segment::NodeSegmentView,
+        },
     },
     wal::no_wal::NoWal,
 };

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

@@ -1,17 +1,17 @@
-use crate::{api::graph::GraphSegmentOps, segments::graph::segment::MemGraphSegment};
+use crate::{api::graph::GraphPropOps, segments::graph::segment::MemGraphProps};
 use parking_lot::RwLockWriteGuard;
 use raphtory_api::core::entities::properties::prop::Prop;
 use raphtory_core::storage::timeindex::TimeIndexEntry;
 
 /// 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, GS: GraphSegmentOps> {
-    pub mem_segment: RwLockWriteGuard<'a, MemGraphSegment>,
+pub struct GraphWriter<'a, GS: GraphPropOps> {
+    pub mem_segment: RwLockWriteGuard<'a, MemGraphProps>,
     pub graph_props: &'a GS,
 }
 
-impl<'a, GS: GraphSegmentOps> GraphWriter<'a, GS> {
-    pub fn new(graph_props: &'a GS, mem_segment: RwLockWriteGuard<'a, MemGraphSegment>) -> Self {
+impl<'a, GS: GraphPropOps> GraphWriter<'a, GS> {
+    pub fn new(graph_props: &'a GS, mem_segment: RwLockWriteGuard<'a, MemGraphProps>) -> Self {
         Self {
             mem_segment,
             graph_props,
@@ -25,7 +25,7 @@ impl<'a, GS: GraphSegmentOps> GraphWriter<'a, GS> {
         lsn: u64,
     ) {
         let add = self.mem_segment.add_properties(t, props);
-        self.mem_segment.as_mut()[MemGraphSegment::LAYER].set_lsn(lsn);
+        self.mem_segment.as_mut()[MemGraphProps::LAYER].set_lsn(lsn);
         self.graph_props.increment_est_size(add);
     }
 
@@ -35,7 +35,7 @@ impl<'a, GS: GraphSegmentOps> GraphWriter<'a, GS> {
 
     pub fn update_metadata(&mut self, props: impl IntoIterator<Item = (usize, Prop)>, lsn: u64) {
         let add = self.mem_segment.update_metadata(props);
-        self.mem_segment.as_mut()[MemGraphSegment::LAYER].set_lsn(lsn);
+        self.mem_segment.as_mut()[MemGraphProps::LAYER].set_lsn(lsn);
         self.graph_props.increment_est_size(add);
     }
 }

db4-storage/src/pages/graph_store.rs

@@ -1,42 +1,32 @@
-use crate::api::graph::GraphSegmentOps;
+use raphtory_api::core::entities::properties::meta::Meta;
+
+use crate::api::graph::GraphPropOps;
 use crate::error::StorageError;
 use crate::pages::graph_page::writer::GraphWriter;
 use crate::persist::strategy::Config;
-use raphtory_core::entities::properties::graph_meta::GraphMeta;
+
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 /// Backing store for graph temporal properties and graph metadata.
 #[derive(Debug)]
-pub struct GraphStorageInner<GS, EXT> {
+pub struct GraphPropsInner<GS, EXT> {
     /// The graph segment that contains all graph properties and graph metadata.
     /// Unlike node and edge segments, which are split into multiple segments,
     /// there is always only one graph segment.
     page: Arc<GS>,
 
     /// Stores graph prop metadata (prop name -> prop id mappings, etc).
-    graph_meta: Arc<GraphMeta>,
+    graph_meta: Arc<Meta>,
 
     path: Option<PathBuf>,
 
     ext: EXT,
 }
 
-impl<GS: GraphSegmentOps, EXT: Config> GraphStorageInner<GS, EXT> {
-    pub fn new(path: Option<&Path>, ext: EXT) -> Self {
-        let page = Arc::new(GS::new(path));
-        let graph_meta = Arc::new(GraphMeta::new());
-
-        Self {
-            page,
-            path: path.map(|p| p.to_path_buf()),
-            graph_meta,
-            ext,
-        }
-    }
-
-    pub fn new_with_meta(path: Option<&Path>, graph_meta: Arc<GraphMeta>, ext: EXT) -> Self {
-        let page = Arc::new(GS::new(path));
+impl<GS: GraphPropOps<Extension = EXT>, EXT: Config> GraphPropsInner<GS, EXT> {
+    pub fn new_with_meta(path: Option<&Path>, graph_meta: Arc<Meta>, ext: EXT) -> Self {
+        let page = Arc::new(GS::new(graph_meta.clone(), path, ext.clone()));
 
         Self {
             page,
@@ -47,17 +37,16 @@ impl<GS: GraphSegmentOps, EXT: Config> GraphStorageInner<GS, EXT> {
     }
 
     pub fn load(path: impl AsRef<Path>, ext: EXT) -> Result<Self, StorageError> {
-        let graph_meta = Arc::new(GraphMeta::new());
-
+        let graph_meta = Arc::new(Meta::new_for_graph());
         Ok(Self {
-            page: Arc::new(GS::load(path.as_ref())?),
+            page: Arc::new(GS::load(graph_meta.clone(), path.as_ref(), ext.clone())?),
             path: Some(path.as_ref().to_path_buf()),
             graph_meta,
             ext,
         })
     }
 
-    pub fn graph_meta(&self) -> &Arc<GraphMeta> {
+    pub fn graph_meta(&self) -> &Arc<Meta> {
         &self.graph_meta
     }
 

db4-storage/src/pages/mod.rs

@@ -1,21 +1,23 @@
 use crate::{
-    api::{edges::EdgeSegmentOps, graph::GraphSegmentOps, nodes::NodeSegmentOps},
-    error::StorageError, pages::{edge_store::ReadLockedEdgeStorage, node_store::ReadLockedNodeStorage},
+    LocalPOS,
+    api::{edges::EdgeSegmentOps, graph::GraphPropOps, nodes::NodeSegmentOps},
+    error::StorageError,
+    pages::{edge_store::ReadLockedEdgeStorage, node_store::ReadLockedNodeStorage},
     persist::strategy::{Config, PersistentStrategy},
     properties::props_meta_writer::PropsMetaWriter,
     segments::{edge::segment::MemEdgeSegment, node::segment::MemNodeSegment},
-    LocalPOS,
 };
 use edge_page::writer::EdgeWriter;
 use edge_store::EdgeStorageInner;
+use graph_store::GraphPropsInner;
 use node_page::writer::{NodeWriter, WriterPair};
 use node_store::NodeStorageInner;
-use graph_store::GraphStorageInner;
 use parking_lot::RwLockWriteGuard;
 use raphtory_api::core::{
     entities::properties::{meta::Meta, prop::Prop},
     storage::dict_mapper::MaybeNew,
 };
+
 use raphtory_core::{
     entities::{EID, ELID, VID},
     storage::timeindex::TimeIndexEntry,
@@ -29,17 +31,16 @@ use std::{
         atomic::{self, AtomicUsize},
     },
 };
-use raphtory_core::entities::properties::graph_meta::GraphMeta;
 
 pub mod edge_page;
 pub mod edge_store;
+pub mod graph_page;
+pub mod graph_store;
 pub mod layer_counter;
 pub mod locked;
 pub mod node_page;
 pub mod node_store;
 pub mod session;
-pub mod graph_page;
-pub mod graph_store;
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_utils;
 
@@ -49,7 +50,7 @@ pub mod test_utils;
 pub struct GraphStore<NS, ES, GS, EXT: Config> {
     nodes: Arc<NodeStorageInner<NS, EXT>>,
     edges: Arc<EdgeStorageInner<ES, EXT>>,
-    graph: Arc<GraphStorageInner<GS, EXT>>,
+    graph: Arc<GraphPropsInner<GS, EXT>>,
     graph_dir: Option<PathBuf>,
     event_id: AtomicUsize,
     _ext: EXT,
@@ -59,7 +60,7 @@ pub struct GraphStore<NS, ES, GS, EXT: Config> {
 pub struct ReadLockedGraphStore<
     NS: NodeSegmentOps<Extension = EXT>,
     ES: EdgeSegmentOps<Extension = EXT>,
-    GS: GraphSegmentOps,
+    GS: GraphPropOps<Extension = EXT>,
     EXT: Config,
 > {
     pub nodes: Arc<ReadLockedNodeStorage<NS, EXT>>,
@@ -70,7 +71,7 @@ pub struct ReadLockedGraphStore<
 impl<
     NS: NodeSegmentOps<Extension = EXT>,
     ES: EdgeSegmentOps<Extension = EXT>,
-    GS: GraphSegmentOps,
+    GS: GraphPropOps<Extension = EXT>,
     EXT: PersistentStrategy,
 > GraphStore<NS, ES, GS, EXT>
 {
@@ -97,7 +98,7 @@ impl<
         &self.edges
     }
 
-    pub fn graph(&self) -> &Arc<GraphStorageInner<GS, EXT>> {
+    pub fn graph_props(&self) -> &Arc<GraphPropsInner<GS, EXT>> {
         &self.graph
     }
 
@@ -109,7 +110,7 @@ impl<
         self.nodes.prop_meta()
     }
 
-    pub fn graph_meta(&self) -> &GraphMeta {
+    pub fn graph_meta(&self) -> &Meta {
         self.graph.graph_meta()
     }
 
@@ -137,7 +138,7 @@ impl<
         let node_meta = node_storage.prop_meta();
 
         // Load graph temporal properties and metadata
-        let graph_storage = Arc::new(GraphStorageInner::load(graph_path, ext.clone())?);
+        let graph_storage = Arc::new(GraphPropsInner::load(graph_path, ext.clone())?);
 
         for node_type in ext.node_types().iter() {
             node_meta.get_or_create_node_type_id(node_type);
@@ -159,7 +160,7 @@ impl<
         graph_dir: Option<&Path>,
         node_meta: Meta,
         edge_meta: Meta,
-        graph_meta: GraphMeta,
+        graph_meta: Meta,
         ext: EXT,
     ) -> Self {
         let nodes_path = graph_dir.map(|graph_dir| graph_dir.join("nodes"));
@@ -181,14 +182,15 @@ impl<
             edge_meta,
             ext.clone(),
         ));
-        let graph_storage = Arc::new(GraphStorageInner::new_with_meta(
+        let graph_storage = Arc::new(GraphPropsInner::new_with_meta(
             graph_path.as_deref(),
             graph_meta,
             ext.clone(),
         ));
 
         if let Some(graph_dir) = graph_dir {
-            write_graph_config(graph_dir, &ext).expect("Unrecoverable! Failed to write graph config");
+            write_graph_config(graph_dir, &ext)
+                .expect("Unrecoverable! Failed to write graph config");
         }
 
         Self {
@@ -204,7 +206,7 @@ impl<
     pub fn new(graph_dir: Option<&Path>, ext: EXT) -> Self {
         let node_meta = Meta::new_for_nodes();
         let edge_meta = Meta::new_for_edges();
-        let graph_meta = GraphMeta::new();
+        let graph_meta = Meta::new_for_graph();
 
         Self::new_with_meta(graph_dir, node_meta, edge_meta, graph_meta, ext)
     }