fix/fixing filtering by index for n by index (#332)

## Description
<!-- Provide a brief description of the changes in this PR -->
fixing filtering by index for n by index

## Related Issues
<!-- Link to any related issues using #issue_number -->

Closes #

## Checklist when merging to main
<!-- Mark items with "x" when completed -->

- [ ] No compiler warnings (if applicable)
- [ ] Code is formatted with `rustfmt`
- [ ] No useless or dead code (if applicable)
- [ ] Code is easy to understand
- [ ] Doc comments are used for all functions, enums, structs, and
fields (where appropriate)
- [ ] All tests pass
- [ ] Performance has not regressed (assuming change was not to fix a
bug)
- [ ] Version number has been updated in `helix-cli/Cargo.toml` and
`helixdb/Cargo.toml`
- [ ] Lines are kept under 100 characters where possible
- [ ] Code is good

## Additional Notes
<!-- Add any additional information that would be helpful for reviewers
-->

Author: xav-db

helix-db/src/helix_engine/graph_core/ops/source/n_from_index.rs

@@ -6,8 +6,8 @@ use crate::{
     },
     protocol::value::Value,
 };
+use heed3::{RoTxn, byteorder::BE};
 use helix_macros::debug_trace;
-use heed3::{byteorder::BE, RoTxn};
 use serde::Serialize;
 use std::sync::Arc;
 
@@ -16,18 +16,25 @@ pub struct NFromIndex<'a> {
         heed3::RoPrefix<'a, heed3::types::Bytes, heed3::types::LazyDecode<heed3::types::U128<BE>>>,
     txn: &'a RoTxn<'a>,
     storage: Arc<HelixGraphStorage>,
+    label: &'a str,
 }
 
 impl<'a> Iterator for NFromIndex<'a> {
     type Item = Result<TraversalVal, GraphError>;
 
     #[debug_trace("N_FROM_INDEX")]
     fn next(&mut self) -> Option<Self::Item> {
-        if let Some(value) = self.iter.by_ref().next() {
+        for value in self.iter.by_ref() {
             let (_, value) = value.unwrap();
             match value.decode() {
                 Ok(value) => match self.storage.get_node(self.txn, &value) {
-                    Ok(node) => return Some(Ok(TraversalVal::Node(node))),
+                    Ok(node) => {
+                        if node.label == self.label {
+                            return Some(Ok(TraversalVal::Node(node)));
+                        } else {
+                            continue;
+                        }
+                    }
                     Err(e) => {
                         println!("{} Error getting node: {:?}", line!(), e);
                         return Some(Err(GraphError::ConversionError(e.to_string())));
@@ -55,7 +62,7 @@ pub trait NFromIndexAdapter<'a, K: Into<Value> + Serialize>:
     ///
     /// Note that both the `index` and `key` must be provided.
     /// The index must be a valid and existing secondary index and the key should match the type of the index.
-    fn n_from_index(self, index: &'a str, key: &'a K) -> Self::OutputIter
+    fn n_from_index(self, label: &'a str, index: &'a str, key: &'a K) -> Self::OutputIter
     where
         K: Into<Value> + Serialize + Clone;
 }
@@ -66,7 +73,7 @@ impl<'a, I: Iterator<Item = Result<TraversalVal, GraphError>>, K: Into<Value> +
     type OutputIter = RoTraversalIterator<'a, NFromIndex<'a>>;
 
     #[inline]
-    fn n_from_index(self, index: &'a str, key: &'a K) -> Self::OutputIter
+    fn n_from_index(self, label: &'a str, index: &'a str, key: &'a K) -> Self::OutputIter
     where
         K: Into<Value> + Serialize + Clone,
     {
@@ -88,6 +95,7 @@ impl<'a, I: Iterator<Item = Result<TraversalVal, GraphError>>, K: Into<Value> +
             iter: res,
             txn: self.txn,
             storage: Arc::clone(&self.storage),
+            label,
         };
 
         RoTraversalIterator {

helix-db/src/helix_engine/graph_core/traversal_tests.rs

@@ -2708,7 +2708,7 @@ fn test_update_of_secondary_indices() {
     let txn = storage.graph_env.read_txn().unwrap();
 
     let node = G::new(Arc::clone(&storage), &txn)
-        .n_from_index("name", &"Jane".to_string())
+        .n_from_index("person", "name", &"Jane".to_string())
         .collect_to::<Vec<_>>();
     assert_eq!(node.len(), 1);
     assert_eq!(node[0].id(), node.id());
@@ -2722,7 +2722,7 @@ fn test_update_of_secondary_indices() {
     }
 
     let node = G::new(Arc::clone(&storage), &txn)
-        .n_from_index("name", &"John".to_string())
+        .n_from_index("person", "name", &"John".to_string())
         .collect_to::<Vec<_>>();
     assert_eq!(node.len(), 0);
 

helix-db/src/helixc/analyzer/methods/traversal_validation.rs

@@ -120,6 +120,7 @@ pub(crate) fn validate_traversal<'a>(
                         };
                         gen_traversal.source_step =
                             Separator::Period(SourceStep::NFromIndex(NFromIndex {
+                                label: GenRef::Literal(node_type.clone()),
                                 index: GenRef::Literal(match *index {
                                     IdType::Identifier { value, loc: _ } => value,
                                     // would be caught by the parser

helix-db/src/helixc/generator/source_steps.rs

@@ -196,11 +196,12 @@ impl Display for SearchVector {
 pub struct NFromIndex {
     pub index: GenRef<String>,
     pub key: GeneratedValue,
+    pub label: GenRef<String>,
 }
 
 impl Display for NFromIndex {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "n_from_index({}, {})", self.index, self.key)
+        write!(f, "n_from_index({}, {}, {})", self.label, self.index, self.key)
     }
 }