more work yo use read_selected to avoid read cost

Author: shisoft

src/graph/edge/bilateral.rs

@@ -209,4 +209,4 @@ pub trait BilateralEdge: TEdge + Sync + Send {
     fn cell_id(&self) -> Option<Id> {
         self.edge_cell().as_ref().map(|cell| cell.id())
     }
-}
+}

src/graph/id_list.rs

@@ -107,6 +107,14 @@ async fn seg_cell_by_id(txn: &Transaction, id: Option<Id>) -> Result<Option<Owne
         None => Ok(None),
     }
 }
+
+async fn seg_list_by_id(txn: &Transaction, id: Option<Id>) -> Result<Option<OwnedCell>, TxnError> {
+    match id {
+        Some(id) => txn.read_selected(id, vec![*LIST_KEY_ID]).await,
+        None => Ok(None),
+    }
+}
+
 pub struct IdList<'a> {
     pub txn: &'a Transaction,
     container_id: Id,
@@ -186,11 +194,9 @@ impl<'a> IdList<'a> {
 
         // Find or create the specific list for this schema
         if ensure_container {
-            self.get_ensured_schema_list_id(type_list_id)
-                .await
+            self.get_ensured_schema_list_id(type_list_id).await
         } else {
-            self.get_schema_list_id(type_list_id)
-                .await
+            self.get_schema_list_id(type_list_id).await
         }
     }
 
@@ -266,7 +272,11 @@ impl<'a> IdList<'a> {
         type_list_id: Id,
     ) -> Result<Result<Id, IdListError>, TxnError> {
         // Read the type list cell
-        let type_list_cell = match self.txn.read_selected(type_list_id, vec![*ID_TYPES_MAP_ID]).await? {
+        let type_list_cell = match self
+            .txn
+            .read_selected(type_list_id, vec![*ID_TYPES_MAP_ID])
+            .await?
+        {
             Some(cell) => cell,
             None => {
                 error!("Failed to get type list cell, id {:?}", type_list_id);
@@ -289,37 +299,38 @@ impl<'a> IdList<'a> {
         Ok(Ok(Id::unit_id()))
     }
 
-        /// Gets or creates a list for the specific schema within the type list
-        async fn get_ensured_schema_list_id(
-            &mut self,
-            type_list_id: Id,
-        ) -> Result<Result<Id, IdListError>, TxnError> {
-            // Read the type list cell
-            let type_list_cell = match self.txn.read(type_list_id).await? {
-                Some(cell) => cell,
-                None => {
-                    error!("Failed to get type list cell, id {:?}", type_list_id);
-                    return Ok(Err(IdListError::FormatError));
-                }
-            };
-    
-            // Find existing list for this schema
-            if let OwnedValue::Array(ref type_list) = type_list_cell[*ID_TYPES_MAP_ID] {
-                if let Some(list_id) = self.find_schema_list_id(type_list) {
-                    return Ok(Ok(list_id));
-                }
-            } else {
-                error!(
-                    "Failed to get type list, index {:?} got {:?}",
-                    *ID_TYPES_MAP_ID, type_list_cell
-                );
+    /// Gets or creates a list for the specific schema within the type list
+    /// This function ensures that the type list exists, also slightly heavier than get_schema_list_id
+    async fn get_ensured_schema_list_id(
+        &mut self,
+        type_list_id: Id,
+    ) -> Result<Result<Id, IdListError>, TxnError> {
+        // Read the type list cell
+        let type_list_cell = match self.txn.read(type_list_id).await? {
+            Some(cell) => cell,
+            None => {
+                error!("Failed to get type list cell, id {:?}", type_list_id);
                 return Ok(Err(IdListError::FormatError));
             }
-    
-            // Create new list if needed
-            self.create_schema_list(type_list_cell).await
+        };
+
+        // Find existing list for this schema
+        if let OwnedValue::Array(ref type_list) = type_list_cell[*ID_TYPES_MAP_ID] {
+            if let Some(list_id) = self.find_schema_list_id(type_list) {
+                return Ok(Ok(list_id));
+            }
+        } else {
+            error!(
+                "Failed to get type list, index {:?} got {:?}",
+                *ID_TYPES_MAP_ID, type_list_cell
+            );
+            return Ok(Err(IdListError::FormatError));
         }
 
+        // Create new list if needed
+        self.create_schema_list(type_list_cell).await
+    }
+
     /// Finds an existing list ID for this schema in the type list
     fn find_schema_list_id(&self, type_list: &Vec<OwnedValue>) -> Option<Id> {
         type_list
@@ -678,7 +689,7 @@ impl<'a> IdListSegmentIterator<'a> {
     /// * `None` - If there are no more segments or an error occurred
     pub async fn next(&mut self) -> Option<OwnedCell> {
         let next_id = self.id_iter.next().await;
-        if let Ok(Some(cell)) = seg_cell_by_id(self.id_iter.txn, next_id).await {
+        if let Ok(Some(cell)) = seg_list_by_id(self.id_iter.txn, next_id).await {
             Some(cell)
         } else {
             None
@@ -728,13 +739,11 @@ impl<'a> IdListIterator<'a> {
     /// - List value is not a PrimArray of Ids
     pub fn get_curr_seg_list(&self) -> Option<&Vec<Id>> {
         if let Some(ref cell) = self.current_seg {
-            if let &OwnedValue::Map(ref map) = &cell.data {
-                let list_val = map.get_by_key_id(*LIST_KEY_ID);
-                if let &OwnedValue::PrimArray(OwnedPrimArray::Id(ref list)) = list_val {
-                    return Some(&list);
-                } else {
-                    error!("Expecting primitive array got: {:?}", list_val);
-                }
+            let list_val = &cell[0u64];
+            if let &OwnedValue::PrimArray(OwnedPrimArray::Id(ref list)) = list_val {
+                return Some(&list);
+            } else {
+                error!("Expecting primitive array got: {:?}", list_val);
             }
         }
         None
@@ -791,15 +800,13 @@ impl<'a> IdListIterator<'a> {
             .unwrap_or(None)
             .cloned();
         if let Some(last_seg) = self.segments.last().await {
-            if let &OwnedValue::Map(ref map) = &last_seg.data {
-                let list_val = map.get_by_key_id(*LIST_KEY_ID);
-                if let &OwnedValue::PrimArray(OwnedPrimArray::Id(ref list)) = list_val {
-                    if let Some(id) = list.last() {
-                        return Some(*id);
-                    }
-                } else {
-                    error!("Expecting primitive array but got {:?}", list_val);
+            let list_val = &last_seg[0u64];
+            if let &OwnedValue::PrimArray(OwnedPrimArray::Id(ref list)) = list_val {
+                if let Some(id) = list.last() {
+                    return Some(*id);
                 }
+            } else {
+                error!("Expecting primitive array but got {:?}", list_val);
             }
         }
         return last_value;
@@ -818,9 +825,9 @@ impl<'a> IdListIterator<'a> {
     {
         let mut count = self.get_curr_seg_list().map(|l| l.len()).unwrap_or(0);
         while let Some(seg) = self.segments.next().await {
-            if let &OwnedValue::Map(ref map) = &seg.data {
-                if let &OwnedValue::PrimArray(OwnedPrimArray::Id(ref list)) =
-                    map.get_by_key_id(*LIST_KEY_ID)
+            let list_val = &seg[0u64];
+            if let &OwnedValue::PrimArray(OwnedPrimArray::Id(ref list)) = list_val {
+                count += list.len();
                 {
                     count += list.len();
                 }