protect graph internal state update

Author: swilly22

client_test.go

@@ -2,54 +2,115 @@ package redisgraph
 
 import (
 	"testing"
-
+	"os"
+	"time"
+	"github.com/stretchr/testify/assert"
 	"github.com/gomodule/redigo/redis"
 )
 
-func TestGraphCreation(t *testing.T) {
-	// Setup.
-	conn, _ := redis.Dial("tcp", "0.0.0.0:6379")
-	defer conn.Close()
+var graph Graph
 
+func createGraph() {
+	conn, _ := redis.Dial("tcp", "0.0.0.0:6379")
 	conn.Do("FLUSHALL")
-	rg := GraphNew("social", conn)
+	graph = GraphNew("social", conn)
 
 	// Create 2 nodes connect via a single edge.
-	japan := NodeNew(0, "country", "j", nil)
-	john := NodeNew(0, "person", "p", nil)
-	edge := EdgeNew(0, "visited", john, japan, nil)
+	japan := NodeNew("Country", "j", nil)
+	john := NodeNew("Person", "p", nil)
+	edge := EdgeNew("Visited", john, japan, nil)
 
 	// Set node properties.
 	john.SetProperty("name", "John Doe")
 	john.SetProperty("age", 33)
 	john.SetProperty("gender", "male")
 	john.SetProperty("status", "single")
+	
+	japan.SetProperty("name", "Japan")
+	japan.SetProperty("population", 126800000)
+
+	edge.SetProperty("year", 2017)
 
 	// Introduce entities to graph.
-	rg.AddNode(john)
-	rg.AddNode(japan)
-	rg.AddEdge(edge)
+	graph.AddNode(john)
+	graph.AddNode(japan)
+	graph.AddEdge(edge)
 
 	// Flush graph to DB.
-	resp, err := rg.Commit()
+	_, err := graph.Commit()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func setup() {
+	createGraph()
+}
+
+func shutdown() {
+	graph.Conn.Close()
+}
+
+func TestMain(m *testing.M) {
+    setup()
+    code := m.Run() 
+    shutdown()
+    os.Exit(code)
+}
+
+func TestMatchQuery(t *testing.T) {
+	q := "MATCH (s)-[e]->(d) RETURN s,e,d"
+	res, err := graph.Query(q)
 	if err != nil {
 		t.Error(err)
 	}
+	
+	assert.Equal(t, len(res.results), 1, "expecting 1 result record")
+
+	s, ok := (res.results[0][0]).(*Node)
+	assert.True(t, ok, "First column should contain nodes.")
+	e, ok := (res.results[0][1]).(*Edge)
+	assert.True(t, ok, "Second column should contain edges.")
+	d, ok := (res.results[0][2]).(*Node)
+	assert.True(t, ok, "Third column should contain nodes.")
+
+	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.")
+}
 
-	// Validate response.
-	if(resp.results != nil) {
-		t.FailNow()
+func TestCreateQuery(t *testing.T) {
+	q := "CREATE (w:WorkPlace {name:'RedisLabs'})"
+	res, err := graph.Query(q)
+	if err != nil {
+		t.Error(err)
 	}
-	if(resp.statistics["Labels added"] != 2) {
-		t.FailNow()
+	
+	assert.True(t, res.Empty(), "Expecting empty result-set")
+	
+	// Validate statistics.
+	assert.Equal(t, res.NodesCreated(), 1, "Expecting a single node to be created.")
+	assert.Equal(t, res.PropertiesSet(), 1, "Expecting a songle property to be added.")
+
+	q = "MATCH (w:WorkPlace) RETURN w"
+	res, err = graph.Query(q)
+	if err != nil {
+		t.Error(err)
 	}
-   	if(resp.statistics["Nodes created"] != 2) {
-   		t.FailNow()
-   	}
-   	if(resp.statistics["Properties set"] != 4) {
-   		t.FailNow()
-   	}
-   	if(resp.statistics["Relationships created"] != 1) {
-   		t.FailNow()
-   	}
+	
+	assert.False(t, res.Empty(), "Expecting resultset to include a single node.")
+	w := (res.results[0][0]).(*Node)
+	assert.Equal(t, w.Label, "WorkPlace", "Unexpected node label.")
 }

edge.go

@@ -17,17 +17,30 @@ type Edge struct {
 	graph *Graph
 }
 
-func EdgeNew(id uint64, relation string, srcNode *Node, destNode *Node, properties map[string]interface{}) *Edge {
+func EdgeNew(relation string, srcNode *Node, destNode *Node, properties map[string]interface{}) *Edge {
+	p := properties 
+	if p == nil {
+		p = make(map[string]interface{})
+	}
+
 	 return &Edge{
-	 	ID:id,
 	 	Relation: relation,
 	 	Source: srcNode,
 	 	Destination: destNode,
-	 	Properties: properties,
+	 	Properties: p,
 	 	graph: nil,	 	
 	 }
 }
 
+func (e *Edge) SetProperty(key string, value interface{}) {
+	e.Properties[key] = value
+}
+
+func (e *Edge) GetProperty(key string) interface{} {
+	v,_ := e.Properties[key]
+	return v
+}
+
 func (e Edge) SourceNodeID() uint64 {
 	if(e.Source != nil) {
 		return e.Source.ID

graph.go

@@ -3,6 +3,7 @@ package redisgraph
 import (
 	"fmt"
 	"strings"
+	"sync"
 
 	"github.com/gomodule/redigo/redis"
 )
@@ -16,6 +17,7 @@ type Graph struct {
 	labels []string 			// List of node labels.
 	relationshipTypes []string 	// List of relation types.
 	properties []string 		// List of properties.
+	mutex sync.Mutex 			// Lock, used for updating internal state.
 }
 
 // New creates a new graph.
@@ -114,47 +116,60 @@ func (g *Graph) Merge(p string) (*QueryResult, error) {
 
 func (g *Graph) getLabel(lblIdx int) string {
 	if lblIdx >= len(g.labels) {
-		// Missing label
-		// refresh label mapping table.
-		g.labels = g.Labels()
+		// Missing label, refresh label mapping table.
+		g.mutex.Lock()
 
-		// Retry.
+		// Recheck now that we've got the lock.
 		if lblIdx >= len(g.labels) {
-			// Error!
-			panic("Unknow label index.")
+			g.labels = g.Labels()
+			// Retry.
+			if lblIdx >= len(g.labels) {
+				// Error!
+				panic("Unknow label index.")
+			}
 		}
+		g.mutex.Unlock()
 	}
 
 	return g.labels[lblIdx]
 }
 
 func (g *Graph) getRelation(relIdx int) string {
 	if relIdx >= len(g.relationshipTypes) {
-		// Missing relation type
-		// refresh relation type mapping table.
-		g.relationshipTypes = g.RelationshipTypes()
+		// Missing relation type, refresh relation type mapping table.
+		g.mutex.Lock()
 
-		// Retry.
+		// Recheck now that we've got the lock.
 		if relIdx >= len(g.relationshipTypes) {
-			// Error!
-			panic("Unknow relation type index.")
+			g.relationshipTypes = g.RelationshipTypes()
+			// Retry.
+			if relIdx >= len(g.relationshipTypes) {
+				// Error!
+				panic("Unknow relation type index.")
+			}
 		}
+		g.mutex.Unlock()
 	}
 
 	return g.relationshipTypes[relIdx]
 }
 
 func (g *Graph) getProperty(propIdx int) string {
 	if propIdx >= len(g.properties) {
-		// Missing property
-		// refresh property mapping table.
-		g.properties = g.PropertyKeys()
+		// Missing property, refresh property mapping table.
+		g.mutex.Lock()
 
-		// Retry.
+		// Recheck now that we've got the lock.
 		if propIdx >= len(g.properties) {
-			// Error!
-			panic("Unknow property index.")
+			g.properties = g.PropertyKeys()
+
+			// Retry.
+			if propIdx >= len(g.properties) {
+				// Error!
+				panic("Unknow property index.")
+			}
 		}
+		g.mutex.Unlock()
 	}
 
 	return g.properties[propIdx]

node.go

@@ -14,15 +14,14 @@ type Node struct {
 	graph *Graph
 }
 
-func NodeNew(id uint64, label string, alias string, properties map[string]interface{}) *Node {
+func NodeNew(label string, alias string, properties map[string]interface{}) *Node {
 
 	p := properties 
 	if p == nil {
 		p = make(map[string]interface{})
 	}
 
-	return &Node{
-	 	ID: id, 
+	return &Node{ 
 	 	Label: label,
 	 	Alias: alias,
 	 	Properties: p,

query_result.go

@@ -10,6 +10,16 @@ import (
 	"github.com/olekukonko/tablewriter"
 )
 
+const (
+	LABELS_ADDED string = "Labels added"
+	NODES_CREATED string = "Nodes created"
+	NODES_DELETED string = "Nodes deleted"
+	RELATIONSHIPS_DELETED string = "Relationships deleted"
+	PROPERTIES_SET string = "Properties set"
+	RELATIONSHIPS_CREATED string = "Relationships created"
+	INTERNAL_EXECUTION_TIME string = "internal execution time"
+)
+
 type ResultSetColumnTypes int
 const (
     COLUMN_UNKNOWN ResultSetColumnTypes = iota
@@ -158,7 +168,9 @@ func (qr *QueryResult) parseNode(cell interface{}) *Node {
     rawProps, _ := redis.Values(c[2], nil)
     properties := qr.parseProperties(rawProps)
 
-    return NodeNew(id, label, "", properties)
+    n := NodeNew(label, "", properties)
+    n.ID = id
+    return n
 }
 
 func (qr *QueryResult) parseEdge(cell interface{}) *Edge {
@@ -177,8 +189,9 @@ func (qr *QueryResult) parseEdge(cell interface{}) *Edge {
     dest_node_id, _ := redis.Uint64(c[3], nil)
     rawProps,_ := redis.Values(c[4], nil)
     properties := qr.parseProperties(rawProps)
-    e := EdgeNew(id, relation, nil, nil, properties)
-    
+    e := EdgeNew(relation, nil, nil, properties)
+
+    e.ID = id
     e.srcNodeID = src_node_id
 	e.destNodeID = dest_node_id
     return e
@@ -242,3 +255,40 @@ func (qr *QueryResult) PrettyPrint() {
 
 	fmt.Fprintf(os.Stdout, "\n")
 }
+
+
+func (qr *QueryResult) getStat(stat string) int {
+	if val, ok := qr.statistics[stat]; ok {
+		return int(val)
+	} else {
+		return 0
+	}
+}
+
+func (qr *QueryResult) LabelsAdded() int {
+	return qr.getStat(LABELS_ADDED)
+}
+
+func (qr *QueryResult) NodesCreated() int {
+	return qr.getStat(NODES_CREATED)
+}
+
+func (qr *QueryResult) NodesDeleted() int {
+	return qr.getStat(NODES_DELETED)
+}
+
+func (qr *QueryResult) PropertiesSet() int {
+	return qr.getStat(PROPERTIES_SET)
+}
+
+func (qr *QueryResult) RelationshipsCreated() int {
+	return qr.getStat(RELATIONSHIPS_CREATED)
+}
+
+func (qr *QueryResult) RelationshipsDeleted() int {
+	return qr.getStat(RELATIONSHIPS_DELETED)
+}
+
+func (qr *QueryResult) RunTime() int {
+	return qr.getStat(INTERNAL_EXECUTION_TIME)
+}