Graph Definition Language (GDL)

Inspired by the Neo4j Cypher query language, GDL allows the simple definition of property graphs. GDL contains a parser and simple structs that represent the property graph and its elements. The Rust implementation is inspired by my Java implementation.

Property graph data model

A property graph consists of nodes and relationships. Nodes have zero or more labels, relationships have zero or one relationship type. Both, nodes and relationships have properties, organized as key-value-pairs. Relationships are directed, starting at a source node and pointing at a target node.

Quickstart example

```rust use gdl::{CypherValue, Graph}; use std::rc::Rc;

let gdl_string = "(alice:Person { age: 23 }), (bob:Person { age: 42 }), (alice)-[r:KNOWS { since: 1984 }]->(bob)";

let graph = Graph::from(gdl_string).unwrap();

asserteq!(graph.nodecount(), 2); asserteq!(graph.relationshipcount(), 1);

let alice = graph.getnode("alice").unwrap(); asserteq!(alice.properties.get("age"), Some(&CypherValue::Integer(23)));

let relationship = graph.getrelationship("r").unwrap(); asserteq!(relationship.rel_type, Some(Rc::new(String::from("KNOWS")))); ```

More GDL language examples

Define a node:

```rust let g = gdl::Graph::from("()").unwrap();

asserteq!(g.nodecount(), 1); ```

Define a node and assign it to variable alice:

```rust let g = gdl::Graph::from("(alice)").unwrap();

assert!(g.getnode("alice").issome()); ```

Define a node with label User and a single property:

```rust let g = gdl::Graph::from("(alice:User { age : 23 })").unwrap();

asserteq!(g.getnode("alice").unwrap().labels.len(), 1); assert!(g.getnode("alice").unwrap().properties.get("age").issome()); ```

Define an outgoing relationship:

```rust let g = gdl::Graph::from("(alice)-->()").unwrap();

asserteq!(g.relationshipcount(), 1); ```

Define an incoming relationship:

```rust let g = gdl::Graph::from("(alice)<--()").unwrap();

asserteq!(g.relationshipcount(), 1); ```

Define a relationship with type KNOWS, assign it to variable r1 and add a property:

```rust use std::rc::Rc;

let g = gdl::Graph::from("(alice)-[r1:KNOWS { since : 2014 }]->(bob)").unwrap();

assert!(g.getrelationship("r1").issome()); asserteq!(g.getrelationship("r1").unwrap().rel_type, Some(Rc::new(String::from("KNOWS")))); ```

Define multiple outgoing relationships from the same source node (i.e. alice):

```rust let g = gdl::Graph::from(" (alice)-[r1:KNOWS { since : 2014 }]->(bob) (alice)-[r2:KNOWS { since : 2013 }]->(eve) ").unwrap();

asserteq!(g.nodecount(), 3); asserteq!(g.relationshipcount(), 2); ```

Define paths (four nodes and three relationships are created):

```rust let g = gdl::Graph::from("()-->()<--()-->()").unwrap();

asserteq!(g.nodecount(), 4); asserteq!(g.relationshipcount(), 3); ```

Paths can be comma separated to express arbitrary complex patterns:

```rust let g = gdl::Graph::from(" ()-->()<--()-->(), ()<--()-->()-->(), ()-->()<--()-->() ").unwrap();

asserteq!(g.nodecount(), 12); asserteq!(g.relationshipcount(), 9); ```

License

Apache 2.0 or MIT