Merge pull request #5 from arangodb/feature/only-populate-user-defined-fields

do not add additional not required data into columns

Author: hkernbach

src/graph_loader.rs

@@ -218,15 +218,15 @@ impl GraphLoader {
     }
 
     fn verify_parameters(&self) -> Result<(), GraphLoaderError> {
-        if !self.get_all_vertices_fields_as_list().is_empty()
+        if !self.get_all_vertices_fields_to_fetch_as_list().is_empty()
             && self.load_config.load_all_vertex_attributes
         {
             return Err(GraphLoaderError::from(
                 "load_all_vertex_attributes is set to true, but vertex collections are not empty."
                     .to_string(),
             ));
         }
-        if !self.get_all_edges_fields_as_list().is_empty()
+        if !self.get_all_edges_fields_to_fetch_as_list().is_empty()
             && self.load_config.load_all_edge_attributes
         {
             return Err(GraphLoaderError::from(
@@ -358,7 +358,7 @@ impl GraphLoader {
                 let (sender, mut receiver) = tokio::sync::mpsc::channel::<Bytes>(10);
                 senders.push(sender);
 
-                let vertex_global_fields = self.get_all_vertices_fields_as_list();
+                let vertex_global_fields = self.get_all_vertex_fields_as_list_to_return();
                 let insert_vertex_clone = vertices_function.clone();
                 let strategy_clone = self.load_strategy;
                 let load_config_clone = self.load_config.clone();
@@ -597,7 +597,7 @@ impl GraphLoader {
             let (sender, mut receiver) = tokio::sync::mpsc::channel::<Bytes>(10);
             senders.push(sender);
 
-            let edge_global_fields = self.get_all_edges_fields_as_list();
+            let edge_global_fields = self.get_all_edges_fields_as_list_to_return();
             let insert_edge_clone = edges_function.clone();
             let strategy_clone = self.load_strategy;
             let load_config_clone = self.load_config.clone();
@@ -859,22 +859,15 @@ impl GraphLoader {
         self.e_collections.keys().cloned().collect()
     }
 
-    pub fn get_all_vertices_fields_as_hashmap(&self) -> HashMap<String, Vec<String>> {
-        self.v_collections
-            .iter()
-            .map(|(k, v)| (k.clone(), v.fields.clone()))
-            .collect()
-    }
-
-    pub fn get_vertex_fields_as_list(&self, collection_name: &String) -> Vec<String> {
+    pub fn get_all_vertex_fields_as_list_to_return(&self) -> Vec<String> {
         let mut fields = vec![];
-        if let Some(c) = self.v_collections.get(collection_name) {
+        for c in self.v_collections.values() {
             fields.extend(c.fields.clone());
         }
         fields
     }
 
-    pub fn get_all_vertices_fields_as_list(&self) -> Vec<String> {
+    pub fn get_all_vertices_fields_to_fetch_as_list(&self) -> Vec<String> {
         // Guaranteed to be unique
         let mut unique_fields = HashSet::new();
         for fields in self.v_collections.values().flat_map(|c| c.fields.clone()) {
@@ -891,7 +884,15 @@ impl GraphLoader {
         unique_fields.into_iter().collect()
     }
 
-    pub fn get_all_edges_fields_as_list(&self) -> Vec<String> {
+    pub fn get_all_edges_fields_as_list_to_return(&self) -> Vec<String> {
+        let mut fields = vec![];
+        for c in self.e_collections.values() {
+            fields.extend(c.fields.clone());
+        }
+        fields
+    }
+
+    pub fn get_all_edges_fields_to_fetch_as_list(&self) -> Vec<String> {
         // Guaranteed to be unique
         let mut unique_fields = HashSet::new();
         for fields in self.e_collections.values().flat_map(|c| c.fields.clone()) {
@@ -910,17 +911,10 @@ impl GraphLoader {
         unique_fields.into_iter().collect()
     }
 
-    pub fn get_all_edges_fields_as_hashmap(&self) -> HashMap<String, Vec<String>> {
-        self.e_collections
-            .iter()
-            .map(|(k, v)| (k.clone(), v.fields.clone()))
-            .collect()
-    }
-
     pub fn produce_vertex_projections(&self) -> Option<HashMap<String, Vec<String>>> {
         assert!(self.supports_projections.unwrap());
         let mut potential_vertex_projections: Option<HashMap<String, Vec<String>>> = None;
-        let vertex_global_fields = self.get_all_vertices_fields_as_list();
+        let vertex_global_fields = self.get_all_vertices_fields_to_fetch_as_list();
 
         // We can only make use of projections in case:
         // 1.) The user has not requested all vertex attributes
@@ -941,7 +935,7 @@ impl GraphLoader {
     pub fn produce_edge_projections(&self) -> Option<HashMap<String, Vec<String>>> {
         assert!(self.supports_projections.unwrap());
         let mut potential_edge_projections: Option<HashMap<String, Vec<String>>> = None;
-        let edge_global_fields = self.get_all_edges_fields_as_list();
+        let edge_global_fields = self.get_all_edges_fields_to_fetch_as_list();
 
         // We can only make use of projections in case:
         // 1.) The user has not requested all vertex attributes

tests/graph_loader.rs

@@ -206,25 +206,20 @@ async fn init_named_graph_loader_with_data() {
 
     // check that data is loaded.
     // in this case, no global vertex attributes have been requested
-    // therefore only the _key attribute is loaded for vertex documents
+    // therefore only the _id attribute is loaded for vertex documents
     let graph_loader = graph_loader_res.unwrap();
     let handle_vertices = move |vertex_ids: &Vec<Vec<u8>>,
                                 columns: &mut Vec<Vec<Value>>,
                                 vertex_field_names: &Vec<String>| {
         assert_eq!(vertex_ids.len(), 10);
 
         assert_eq!(columns.len(), 10);
-        for (v_index, vertex) in columns.iter().enumerate() {
-            assert_eq!(vertex.len(), 1);
+        for (_v_index, vertex) in columns.iter().enumerate() {
+            assert_eq!(vertex.len(), 0);
             assert_eq!(vertex.len(), vertex_field_names.len());
-            let element_0 = &vertex[0];
-            let id = element_0.as_str().unwrap();
-            let expected_id = format!("{}/{}", VERTEX_COLLECTION, v_index);
-            assert_eq!(id.to_string(), expected_id);
         }
 
-        assert_eq!(vertex_field_names.len(), 1);
-        assert_eq!(vertex_field_names[0], "_id");
+        assert_eq!(vertex_field_names.len(), 0);
         Ok(())
     };
     let vertices_result = graph_loader.do_vertices(handle_vertices).await;
@@ -236,23 +231,22 @@ async fn init_named_graph_loader_with_data() {
                              edge_field_names: &Vec<String>| {
         assert_eq!(from_ids.len(), 9);
         assert_eq!(from_ids.len(), to_ids.len());
+        assert_eq!(to_ids.len(), 9);
+        assert_eq!(to_ids.len(), columns.len());
         assert_eq!(columns.len(), 9);
 
-        for (v_index, edge) in columns.iter().enumerate() {
-            assert_eq!(edge.len(), 2);
-            assert_eq!(edge.len(), edge_field_names.len());
-            let element_0 = &edge[0];
-            let from_id = element_0.as_str().unwrap();
-            let to_id = &edge[1].as_str().unwrap();
-            let expected_from_id = format!("{}/{}", VERTEX_COLLECTION, v_index);
-            let expected_to_id = format!("{}/{}", VERTEX_COLLECTION, v_index + 1);
-            assert_eq!(from_id.to_string(), expected_from_id);
-            assert_eq!(to_id.to_string(), expected_to_id);
+        for (from_idx, from_id) in from_ids.iter().enumerate() {
+            let from_id_str = from_id.iter().map(|x| *x as char).collect::<String>();
+            let expected_from_id = format!("{}/{}", VERTEX_COLLECTION, from_idx);
+            assert_eq!(from_id_str, expected_from_id);
+        }
+        for (to_idx, to_id) in to_ids.iter().enumerate() {
+            let to_id_str = to_id.iter().map(|x| *x as char).collect::<String>();
+            let expected_to_id = format!("{}/{}", VERTEX_COLLECTION, to_idx + 1);
+            assert_eq!(to_id_str, expected_to_id);
         }
 
-        assert_eq!(edge_field_names.len(), 2);
-        assert_eq!(edge_field_names[0], "_from");
-        assert_eq!(edge_field_names[1], "_to");
+        assert_eq!(edge_field_names.len(), 0);
         Ok(())
     };
     let edges_result = graph_loader.do_edges(handle_edges).await;