falkordb 0.2.1

A FalkorDB Rust client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

/*
 * Copyright FalkorDB Ltd. 2023 - present
 * Licensed under the MIT License.
 */

use crate::{parser::redis_value_as_vec, Edge, FalkorDBError, FalkorResult, GraphSchema, Node};

/// Represents a path between two nodes, contains all the nodes, and the relationships between them along the path
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Path {
    /// The nodes along the path, ordered
    pub nodes: Vec<Node>,
    /// The relationships between the nodes in the path, ordered
    pub relationships: Vec<Edge>,
}

impl Path {
    #[cfg_attr(
        feature = "tracing",
        tracing::instrument(name = "Parse Path", skip_all, level = "debug")
    )]
    pub(crate) fn parse(
        value: redis::Value,
        graph_schema: &mut GraphSchema,
    ) -> FalkorResult<Self> {
        let [nodes, relationships]: [redis::Value; 2] =
            redis_value_as_vec(value).and_then(|vec_val| {
                vec_val.try_into().map_err(|_| {
                    FalkorDBError::ParsingArrayToStructElementCount(
                        "Expected exactly 2 elements for path",
                    )
                })
            })?;

        Ok(Self {
            nodes: redis_value_as_vec(nodes)?
                .into_iter()
                .flat_map(|node| Node::parse(node, graph_schema))
                .collect(),
            relationships: redis_value_as_vec(relationships)?
                .into_iter()
                .flat_map(|edge| Edge::parse(edge, graph_schema))
                .collect(),
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_path_default() {
        let path = Path::default();
        assert!(path.nodes.is_empty());
        assert!(path.relationships.is_empty());
    }

    #[test]
    fn test_path_clone() {
        let node1 = Node {
            entity_id: 1,
            labels: vec!["Person".to_string()],
            properties: std::collections::HashMap::new(),
        };
        let node2 = Node {
            entity_id: 2,
            labels: vec!["Person".to_string()],
            properties: std::collections::HashMap::new(),
        };
        let edge = Edge {
            entity_id: 1,
            relationship_type: "KNOWS".to_string(),
            src_node_id: 1,
            dst_node_id: 2,
            properties: std::collections::HashMap::new(),
        };

        let path = Path {
            nodes: vec![node1, node2],
            relationships: vec![edge],
        };

        let path_clone = path.clone();
        assert_eq!(path, path_clone);
        assert_eq!(path.nodes.len(), path_clone.nodes.len());
        assert_eq!(path.relationships.len(), path_clone.relationships.len());
    }

    #[test]
    fn test_path_debug() {
        let path = Path {
            nodes: vec![],
            relationships: vec![],
        };
        let debug_str = format!("{:?}", path);
        assert!(debug_str.contains("Path"));
        assert!(debug_str.contains("nodes"));
        assert!(debug_str.contains("relationships"));
    }

    #[test]
    fn test_path_equality() {
        let path1 = Path::default();
        let path2 = Path::default();
        assert_eq!(path1, path2);
    }

    #[test]
    fn test_path_with_nodes_and_edges() {
        let node = Node {
            entity_id: 1,
            labels: vec!["Test".to_string()],
            properties: std::collections::HashMap::new(),
        };
        let edge = Edge {
            entity_id: 1,
            relationship_type: "TEST_REL".to_string(),
            src_node_id: 1,
            dst_node_id: 2,
            properties: std::collections::HashMap::new(),
        };

        let path = Path {
            nodes: vec![node],
            relationships: vec![edge],
        };

        assert_eq!(path.nodes.len(), 1);
        assert_eq!(path.relationships.len(), 1);
        assert_eq!(path.nodes[0].entity_id, 1);
        assert_eq!(path.relationships[0].entity_id, 1);
    }
}