alignment

Author: shisoft

src/apps/hnsw/partition/search.rs

@@ -393,6 +393,12 @@ impl HnswOnlinePartition {
                 }
                 Err(NeighbourhoodError::IdListError(IdListError::ContainerCellNotReady)) => {
                     // If the container cell is not ready, we need to prepare the it
+                    append_job_log(
+                        logger,
+                        job_id,
+                        JobLogLevel::Info,
+                        format!("Container cell not ready for vertex {:?}, preparing it", id),
+                    );
                     let field_id = ed.as_field();
                     let _ = engine
                         .graph_transaction(DefaultPartitioner, move |txn| {
@@ -650,6 +656,17 @@ impl HnswOnlinePartition {
                     EdgeDirection::Undirected,
                 ) {
                     Ok(neighbors) => {
+                        append_job_log(
+                            logger,
+                            job_id,
+                            JobLogLevel::Info,
+                            format!(
+                                "Found {} neighbors for vertex {:?} with level schema {}",
+                                neighbors.len(),
+                                current_vertex,
+                                level_schema
+                            ),
+                        );
                         for (neighbor_id, _) in neighbors {
                             let is_local = self.conshash.get_server_id(neighbor_id.higher)
                                 == Some(self.server_id);
@@ -895,7 +912,18 @@ impl HnswOnlinePartition {
                     job_id,
                 )
                 .await?;
-
+            append_job_log(
+                logger,
+                job_id,
+                JobLogLevel::Info,
+                format!(
+                    "Found {} nearest neighbors at level {} for vertex {:?}, with entry points {:?}",
+                    nearest_neighbors.len(),
+                    level,
+                    vertex_id,
+                    entry_points
+                ),
+            );
             // Apply the neighbor selection heuristic to choose diverse neighbors
             let selected_neighbors = self.select_neighbors_heuristic(
                 &vertex_id,
@@ -919,6 +947,15 @@ impl HnswOnlinePartition {
             );
             for neighbor_id in &selected_neighbors {
                 // Create bidirectional edges
+                append_job_log(
+                    logger,
+                    job_id,
+                    JobLogLevel::Info,
+                    format!(
+                        "Connecting vertex {:?} to neighbor {:?} at level {}",
+                        vertex_id, neighbor_id, level
+                    ),
+                );
                 match engine
                     .link(
                         vertex_id,    // from (new vertex)

src/graph/mod.rs

@@ -517,36 +517,36 @@ impl GraphEngine {
         V: ToVertexId,
     {
         let vertex_field = ed.as_field();
-        let edge_schema_id = edge_schema.to_id(&self.schemas);
-        let vertex_id = vertex.to_id();
-        let edge_attr = match self.schemas.schema_type(edge_schema_id) {
+        let schema_id = edge_schema.to_id(&self.schemas);
+        let vertex_id = &vertex.to_id();
+        let edge_attrs = match self.schemas.schema_type(schema_id) {
             Some(GraphSchema::Edge(ea)) => ea,
-            Some(_) => return Err(NeighbourhoodError::EdgeError(EdgeError::WrongSchema)),
-            None => return Err(NeighbourhoodError::EdgeError(EdgeError::CannotFindSchema)),
+            _ => {
+                return Err(NeighbourhoodError::EdgeError(
+                    EdgeError::CannotFindSchema,
+                ))
+            }
         };
-        if edge_attr.has_body {
-            return Err(NeighbourhoodError::LocalEdgeCannotHaveBody);
-        }
-        match LocalIdList::new(&*self.local_chunks, vertex_id, vertex_field, edge_schema_id).iter()
+        match LocalIdList::new(&*self.local_chunks, *vertex_id, vertex_field, schema_id).iter()
         {
             Ok(Ok(mut id_list)) => {
                 let mut result = Vec::new();
                 while let Some(opposite_id) = id_list.next() {
-                    match edge_attr.edge_type {
+                    match edge_attrs.edge_type {
                         EdgeType::Directed => {
                             let edge = DirectedEdge::build_edge(
-                                vertex_id,
+                                *vertex_id,
                                 opposite_id,
-                                edge_schema_id,
+                                schema_id,
                                 None,
                             );
                             result.push((opposite_id, Edge::Directed(edge)));
                         }
                         EdgeType::Undirected => {
                             let edge = UndirectedEdge::build_edge(
-                                vertex_id,
+                                *vertex_id,
                                 opposite_id,
-                                edge_schema_id,
+                                schema_id,
                                 None,
                             );
                             result.push((opposite_id, Edge::Undirected(edge)));