graphml 0.1.1

Streaming GraphML parser producing owned property-graph nodes and edges, with optional Tokio async reading
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

//! Conversions into the format-neutral `property-graph-model` records.
//!
//! Enabled by the `property-graph-model` feature. Each parsed record
//! maps field-for-field so a streaming import pipeline can hand the
//! parser's output straight to any consumer of `PgNode` / `PgEdge`.

use property_graph_model::{
    PgEdge,
    PgNode,
    PgProperty,
};

use crate::types::{
    Edge,
    Node,
    Property,
};

impl From<Property> for PgProperty {
    fn from(property: Property) -> Self {
        Self {
            key: property.name,
            value: property.value,
            type_hint: property.type_hint,
        }
    }
}

impl From<Node> for PgNode {
    fn from(node: Node) -> Self {
        Self {
            source_id: node.id,
            labels: node.labels,
            properties: node.properties.into_iter().map(PgProperty::from).collect(),
        }
    }
}

impl From<Edge> for PgEdge {
    fn from(edge: Edge) -> Self {
        Self {
            source_id: edge.source,
            target_id: edge.target,
            rel_type: edge.label,
            properties: edge.properties.into_iter().map(PgProperty::from).collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use property_graph_model::{
        PgEdge,
        PgNode,
    };

    use crate::parse_graphml;

    #[test]
    fn parsed_records_convert_field_for_field() {
        let input = r#"<graphml><key id="age" for="node" attr.name="age" attr.type="int"/><key id="labels" for="node" attr.name="labels"/><graph>
          <node id="1"><data key="labels">Person</data><data key="age">30</data></node>
          <edge source="1" target="2" label="KNOWS"/>
        </graph></graphml>"#;
        let (nodes, edges) = parse_graphml(input).expect("parse");
        let node = PgNode::from(nodes.into_iter().next().expect("one node"));
        assert_eq!(node.source_id, "1");
        assert_eq!(node.labels, vec!["Person"]);
        assert_eq!(node.properties[0].key, "age");
        assert_eq!(node.properties[0].type_hint.as_deref(), Some("int"));

        let edge = PgEdge::from(edges.into_iter().next().expect("one edge"));
        assert_eq!(edge.source_id, "1");
        assert_eq!(edge.target_id, "2");
        assert_eq!(edge.rel_type, "KNOWS");
    }
}