added path support

Author: DvirDukhan

README.md

@@ -86,6 +86,14 @@ func main() {
         p_age, _ := r.Get("p.age")
         fmt.Printf("\nAge: %d\n", p_age)
     }
+
+    // Path matching example.
+    query = "MATCH p = (:Person)-[:Visited]->(:Country) RETURN p"
+    result, _ = graph.Query(query)
+    res.Next()
+    r := res.Record()
+    p, ok := r.GetByIndex(0).(Path)
+    fmt.Printf("%v", p.Encode())
 }
 ```
 

client_test.go

@@ -215,3 +215,44 @@ func TestArray(t *testing.T) {
 	assert.Equal(t, b.GetProperty("age"), resB.GetProperty("age"), "Unexpected property value.")
 	assert.Equal(t, b.GetProperty("array"), resB.GetProperty("array"), "Unexpected property value.")
 }
+
+func TestPath(t *testing.T) {
+	createGraph()
+	q := "MATCH p = (:Person)-[:Visited]->(:Country) RETURN p"
+	res, err := graph.Query(q)
+	if err != nil {
+		t.Error(err)
+	}
+
+	assert.Equal(t, len(res.results), 1, "expecting 1 result record")
+
+	res.Next()
+	r := res.Record()
+	
+	p, ok := r.GetByIndex(0).(Path)
+	assert.True(t, ok, "First column should contain path.")
+
+	assert.Equal(t, 2, p.NodesCount(), "Path should contain two nodes")
+	assert.Equal(t, 1, p.EdgeCount(), "Path should contain one edge")
+
+	s := p.FirstNode()
+	e := p.GetEdge(0)
+	d := p.LastNode()
+
+	assert.Equal(t, s.Label, "Person", "Node should be of type 'Person'")
+	assert.Equal(t, e.Relation, "Visited", "Edge should be of relation type 'Visited'")
+	assert.Equal(t, d.Label, "Country", "Node should be of type 'Country'")
+
+	assert.Equal(t, len(s.Properties), 4, "Person node should have 4 properties")
+
+	assert.Equal(t, s.GetProperty("name"), "John Doe", "Unexpected property value.")
+	assert.Equal(t, s.GetProperty("age"), 33, "Unexpected property value.")
+	assert.Equal(t, s.GetProperty("gender"), "male", "Unexpected property value.")
+	assert.Equal(t, s.GetProperty("status"), "single", "Unexpected property value.")
+
+	assert.Equal(t, e.GetProperty("year"), 2017, "Unexpected property value.")
+
+	assert.Equal(t, d.GetProperty("name"), "Japan", "Unexpected property value.")
+	assert.Equal(t, d.GetProperty("population"), 126800000, "Unexpected property value.")
+
+}

path.go

@@ -0,0 +1,69 @@
+package redisgraph
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Path struct {
+	Nodes []interface{}
+	Edges []interface{}
+}
+
+func PathNew(nodes []interface{}, edges []interface{}) Path {
+	return Path{
+		Nodes: nodes,
+		Edges: edges,
+	}
+}
+
+func (p Path) GetNodes() []interface{} {
+	return p.Nodes
+}
+
+func (p Path) GetEdges() []interface{} {
+	return p.Edges
+}
+
+func (p Path) GetNode(index int) *Node {
+	return p.Nodes[index].(*Node)
+}
+
+func (p Path) GetEdge(index int) *Edge{
+	return p.Edges[index].(*Edge);
+}
+
+func (p Path) FirstNode() *Node {
+	return p.GetNode(0)
+}
+
+func (p Path) LastNode() *Node {
+	return p.GetNode(p.NodesCount() - 1)
+}
+
+func (p Path) NodesCount() int {
+	return len(p.Nodes)
+}
+
+func (p Path) EdgeCount() int {
+	return len(p.Edges)
+}
+
+func (p Path) Encode() string {
+	s := []string{"<"}
+	edgeCount := p.EdgeCount()
+	for i := 0; i < edgeCount; i++ {
+		var node = p.GetNode(i)
+		s = append(s, "(" , fmt.Sprintf("%v", node.ID) , ")")
+		var edge = p.GetEdge(i)
+		if node.ID == edge.srcNodeID {
+			s = append(s, "-[" , fmt.Sprintf("%v", edge.ID) , "]->")
+		} else {
+			s= append(s, "<-[" , fmt.Sprintf("%v", edge.ID) , "]-")
+		}
+	}
+	s = append(s, "(" , fmt.Sprintf("%v", p.GetNode(edgeCount).ID) , ")")
+	s = append(s, ">")
+
+	return strings.Join(s, "")
+}

query_result.go

@@ -41,6 +41,7 @@ const (
 	VALUE_ARRAY
 	VALUE_EDGE
 	VALUE_NODE
+	VALUE_PATH
 )
 
 type QueryResultHeader struct {
@@ -217,6 +218,13 @@ func (qr *QueryResult) parseArray(cell interface{}) []interface{} {
 	return array
 }
 
+func (qr *QueryResult) parsePath(cell interface{}) Path {
+	arrays := cell.([]interface{})
+	nodes := qr.parseScalar(arrays[0].([]interface{}))
+	edges := qr.parseScalar(arrays[1].([]interface{}))
+	return PathNew(nodes.([]interface{}), edges.([]interface{}))
+}
+
 func (qr *QueryResult) parseScalar(cell []interface{}) interface{} {
 	t, _ := redis.Int(cell[0], nil)
 	v := cell[1]
@@ -246,6 +254,9 @@ func (qr *QueryResult) parseScalar(cell []interface{}) interface{} {
 	case VALUE_NODE:
 		s = qr.parseNode(v)
 
+	case VALUE_PATH:
+		s = qr.parsePath(v)
+
 	case VALUE_UNKNOWN:
 		panic("Unknown scalar type\n")
 	}