Merge branch 'master' into master

Author: filipecosta90

client_test.go

@@ -65,6 +65,20 @@ func TestMatchQuery(t *testing.T) {
 		t.Error(err)
 	}
 
+	checkQueryResults(t, res)
+}
+
+func TestMatchROQuery(t *testing.T) {
+	q := "MATCH (s)-[e]->(d) RETURN s,e,d"
+	res, err := graph.ROQuery(q)
+	if err != nil {
+		t.Error(err)
+	}
+
+	checkQueryResults(t, res)
+}
+
+func checkQueryResults(t *testing.T, res *QueryResult) {
 	assert.Equal(t, len(res.results), 1, "expecting 1 result record")
 
 	res.Next()
@@ -120,6 +134,12 @@ func TestCreateQuery(t *testing.T) {
 	assert.Equal(t, w.Label, "WorkPlace", "Unexpected node label.")
 }
 
+func TestCreateROQueryFailure(t *testing.T) {
+	q := "CREATE (w:WorkPlace {name:'RedisLabs'})"
+	_, err := graph.ROQuery(q)
+	assert.NotNil(t, err, "error should not be nil")
+}
+
 func TestErrorReporting(t *testing.T) {
 	q := "RETURN toupper(5)"
 	res, err := graph.Query(q)
@@ -399,3 +419,73 @@ func TestQueryStatistics(t *testing.T) {
 	assert.Nil(t,err)
 	assert.Equal(t, 1, res.RelationshipsDeleted(), "Expecting 1 relationships deleted")
 }
+
+func TestUtils(t *testing.T) {
+	res := RandomString(10)
+	assert.Equal(t, len(res), 10)
+
+	res = ToString("test_string")
+	assert.Equal(t, res, "\"test_string\"")
+	
+	res = ToString(10)
+	assert.Equal(t, res, "10")	
+
+	res = ToString(1.2)
+	assert.Equal(t, res, "1.2")
+
+	res = ToString(true)
+	assert.Equal(t, res, "true")
+
+	var arr = []interface{}{1,2,3,"boom"}
+	res = ToString(arr)
+	assert.Equal(t, res, "[1,2,3,\"boom\"]")
+	
+	jsonMap := make(map[string]interface{})
+	jsonMap["object"] = map[string]interface{} {"foo": 1}
+	res = ToString(jsonMap)
+	assert.Equal(t, res, "{object: {foo: 1}}")
+}
+
+func TestNodeMapDatatype(t *testing.T) {
+	graph.Flush()
+	err := graph.Delete()
+	assert.Nil(t, err)
+
+	// Create 2 nodes connect via a single edge.
+	japan := NodeNew("Country", "j",
+		map[string]interface{}{
+			"name":       "Japan",
+			"population": 126800000,
+			"states":     []string{"Kanto", "Chugoku"},
+		})
+	john := NodeNew("Person", "p",
+		map[string]interface{}{
+			"name":   "John Doe",
+			"age":    33,
+			"gender": "male",
+			"status": "single",
+		})
+	edge := EdgeNew("Visited", john, japan, map[string]interface{}{"year": 2017})
+	// Introduce entities to graph.
+	graph.AddNode(john)
+	graph.AddNode(japan)
+	graph.AddEdge(edge)
+
+	// Flush graph to DB.
+	res, err := graph.Commit()
+	assert.Nil(t, err)
+	assert.Equal(t, 2, res.NodesCreated(), "Expecting 2 node created")
+	assert.Equal(t, 0, res.NodesDeleted(), "Expecting 0 nodes deleted")
+	assert.Equal(t, 8, res.PropertiesSet(), "Expecting 8 properties set")
+	assert.Equal(t, 1, res.RelationshipsCreated(), "Expecting 1 relationships created")
+	assert.Equal(t, 0, res.RelationshipsDeleted(), "Expecting 0 relationships deleted")
+	assert.Greater(t, res.InternalExecutionTime(), 0.0, "Expecting internal execution time not to be 0.0")
+	assert.Equal(t, true, res.Empty(), "Expecting empty resultset")
+	res, err = graph.Query("MATCH p = (:Person)-[:Visited]->(:Country) RETURN p")
+	assert.Nil(t, err)
+	assert.Equal(t, len(res.results), 1, "expecting 1 result record")
+	assert.Equal(t, false, res.Empty(), "Expecting resultset to have records")
+	res, err = graph.Query("MATCH ()-[r]-() DELETE r")
+	assert.Nil(t, err)
+	assert.Equal(t, 1, res.RelationshipsDeleted(), "Expecting 1 relationships deleted")
+}

graph.go

@@ -108,6 +108,17 @@ func (g *Graph) Query(q string) (*QueryResult, error) {
 	return QueryResultNew(g, r)
 }
 
+// ROQuery executes a read only query against the graph.
+func (g *Graph) ROQuery(q string) (*QueryResult, error) {
+
+	r, err := g.Conn.Do("GRAPH.RO_QUERY", g.Id, q, "--compact")
+	if err != nil {
+		return nil, err
+	}
+
+	return QueryResultNew(g, r)
+}
+
 func (g *Graph) ParameterizedQuery(q string, params map[string]interface{}) (*QueryResult, error) {
 	if(params != nil){
 		q = BuildParamsHeader(params) + q

utils.go

@@ -18,6 +18,25 @@ func arrayToString(arr []interface{}) string {
 	return "[" + strings.Join(strArray, ",") + "]"
 }
 
+// go array to string is [1 2 3] for [1, 2, 3] array
+// cypher expects comma separated array
+func strArrayToString(arr []string) string {
+	var arrayLength = len(arr)
+	strArray := []string{}
+	for i := 0; i < arrayLength; i++ {
+		strArray = append(strArray, ToString(arr[i]))
+	}
+	return "[" + strings.Join(strArray, ",") + "]"
+}
+
+func mapToString(data map[string]interface{}) string {
+	pairsArray := []string{}
+	for k, v := range data {
+		pairsArray = append(pairsArray, k + ": " + ToString(v))
+	}
+	return "{" + strings.Join(pairsArray, ",") + "}"
+}
+
 func ToString(i interface{}) string {
 	if(i == nil) {
 		return "null"
@@ -33,9 +52,15 @@ func ToString(i interface{}) string {
 		return strconv.FormatFloat(i.(float64), 'f', -1, 64)
 	case bool:
 		return strconv.FormatBool(i.(bool))
-	case []interface {}:
+	case []interface{}:
 		arr := i.([]interface{})
 		return arrayToString(arr)
+	case map[string]interface{}:
+		data := i.(map[string]interface{})
+		return mapToString(data)
+	case []string:
+		arr := i.([]string)
+		return strArrayToString(arr)
 	default:
 		panic("Unrecognized type to convert to string")
 	}