Merge pull request #17 from RedisGraph/consume-results

result-set consume interface

Author: swilly22

README.md

@@ -25,6 +25,7 @@ $ go get github.com/redislabs/redisgraph-go
 package main
 
 import (
+    "fmt"
     "github.com/gomodule/redigo/redis"
     rg "github.com/redislabs/redisgraph-go"
 )
@@ -64,22 +65,34 @@ func main() {
     graph.Commit()
 
     query := `MATCH (p:person)-[v:visited]->(c:country)
-           RETURN p.name, p.age, v.purpose, c.name`
+           RETURN p.name, p.age, c.name`
     rs, _ := graph.Query(query)
 
     rs.PrettyPrint()
+
+    // Access individual result record.
+    // As long as there are records to consume.
+    for rs.Next() {
+        // Get current record.
+        r := rs.Record()
+
+        p_name := r.GetByIndex(0).(string)
+        p_age := r.GetByIndex(1).(int)
+        c_name := r.GetByIndex(2).(string)
+        fmt.Printf("p_name: %s p_age: %d c_name: %s\n", p_name, p_age, c_name)
+    }
 }
 ```
 
 Running the above should output:
 
 ```sh
 $ go run main.go
-+----------+-----------+-----------+--------+
-|  p.name  |   p.age   | v.purpose | c.name |
-+----------+-----------+-----------+--------+
-| John Doe | 33.000000 | NULL      | Japan  |
-+----------+-----------+-----------+--------+
++----------+-----------+--------+
+|  p.name  |   p.age   | c.name |
++----------+-----------+--------+
+| John Doe | 33.000000 | Japan  |
++----------+-----------+--------+
 ```
 
 ## Running tests

client_test.go

@@ -67,11 +67,14 @@ func TestMatchQuery(t *testing.T) {
 
 	assert.Equal(t, len(res.results), 1, "expecting 1 result record")
 
-	s, ok := (res.results[0][0]).(*Node)
+	res.Next()
+	r := res.Record()
+
+	s, ok := r.GetByIndex(0).(*Node)
 	assert.True(t, ok, "First column should contain nodes.")
-	e, ok := (res.results[0][1]).(*Edge)
+	e, ok := r.GetByIndex(1).(*Edge)
 	assert.True(t, ok, "Second column should contain edges.")
-	d, ok := (res.results[0][2]).(*Node)
+	d, ok := r.GetByIndex(2).(*Node)
 	assert.True(t, ok, "Third column should contain nodes.")
 
 	assert.Equal(t, s.Label, "Person", "Node should be of type 'Person'")
@@ -111,7 +114,9 @@ func TestCreateQuery(t *testing.T) {
 	}
 
 	assert.False(t, res.Empty(), "Expecting resultset to include a single node.")
-	w := (res.results[0][0]).(*Node)
+	res.Next()
+	r := res.Record()
+	w := r.GetByIndex(0).(*Node)
 	assert.Equal(t, w.Label, "WorkPlace", "Unexpected node label.")
 }
 
@@ -149,9 +154,10 @@ func TestArray(t *testing.T) {
 		t.Error(err)
 	}
 
+	res.Next()
+	r := res.Record()
 	assert.Equal(t, len(res.results), 1, "expecting 1 result record")
-
-	assert.Equal(t, []interface{}{0, 1, 2}, res.results[0][0])
+	assert.Equal(t, []interface{}{0, 1, 2}, r.GetByIndex(0))
 
 	q = "unwind([0,1,2]) as x return x"
 	res, err = graph.Query(q)
@@ -160,8 +166,11 @@ func TestArray(t *testing.T) {
 	}
 	assert.Equal(t, len(res.results), 3, "expecting 3 result record")
 
-	for i := 0; i < 3; i++ {
-		assert.Equal(t, i, res.results[i][0])
+	i := 0
+	for res.Next() {
+		r = res.Record()
+		assert.Equal(t, i, r.GetByIndex(0))
+		i++
 	}
 
 	q = "MATCH(n) return collect(n) as x"
@@ -183,7 +192,9 @@ func TestArray(t *testing.T) {
 
 	assert.Equal(t, 1, len(res.results), "expecting 1 results record")
 
-	arr := res.results[0][0].([]interface{})
+	res.Next()
+	r = res.Record()
+	arr := r.GetByIndex(0).([]interface{})
 
 	assert.Equal(t, 2, len(arr))
 

graph.go

@@ -200,7 +200,7 @@ func (g *Graph) Labels() []string {
 	l := make([]string, len(qr.results))
 
 	for idx, r := range qr.results {
-		l[idx] = r[0].(string)
+		l[idx] = r.GetByIndex(0).(string)
 	}
 	return l
 }
@@ -212,7 +212,7 @@ func (g *Graph) RelationshipTypes() []string {
 	rt := make([]string, len(qr.results))
 
 	for idx, r := range qr.results {
-		rt[idx] = r[0].(string)
+		rt[idx] = r.GetByIndex(0).(string)
 	}
 	return rt
 }
@@ -224,7 +224,7 @@ func (g *Graph) PropertyKeys() []string {
 	p := make([]string, len(qr.results))
 
 	for idx, r := range qr.results {
-		p[idx] = r[0].(string)
+		p[idx] = r.GetByIndex(0).(string)
 	}
 	return p
 }

query_result.go

@@ -50,10 +50,11 @@ type QueryResultHeader struct {
 
 // QueryResult represents the results of a query.
 type QueryResult struct {
-	results    [][]interface{}
-	statistics map[string]float64
-	header     QueryResultHeader
-	graph      *Graph
+	graph      			*Graph
+	header     			QueryResultHeader
+	results    			[]*Record
+	statistics 			map[string]float64
+	current_record_idx	int
 }
 
 func QueryResultNew(g *Graph, response interface{}) (*QueryResult, error) {
@@ -65,6 +66,7 @@ func QueryResultNew(g *Graph, response interface{}) (*QueryResult, error) {
 			column_types: make([]ResultSetColumnTypes, 0),
 		},
 		graph: g,
+		current_record_idx: -1,
 	}
 
 	r, _ := redis.Values(response, nil)
@@ -120,31 +122,30 @@ func (qr *QueryResult) parseHeader(raw_header interface{}) {
 
 func (qr *QueryResult) parseRecords(raw_result_set []interface{}) {
 	records, _ := redis.Values(raw_result_set[1], nil)
-
-	qr.results = make([][]interface{}, len(records))
+	qr.results = make([]*Record, len(records))
 
 	for i, r := range records {
 		cells, _ := redis.Values(r, nil)
-		record := make([]interface{}, len(cells))
+		values := make([]interface{}, len(cells))
 
 		for idx, c := range cells {
 			t := qr.header.column_types[idx]
 			switch t {
 			case COLUMN_SCALAR:
 				s, _ := redis.Values(c, nil)
-				record[idx] = qr.parseScalar(s)
+				values[idx] = qr.parseScalar(s)
 				break
 			case COLUMN_NODE:
-				record[idx] = qr.parseNode(c)
+				values[idx] = qr.parseNode(c)
 				break
 			case COLUMN_RELATION:
-				record[idx] = qr.parseEdge(c)
+				values[idx] = qr.parseEdge(c)
 				break
 			default:
 				panic("Unknown column type.")
 			}
 		}
-		qr.results[i] = record
+		qr.results[i] = recordNew(values, qr.header.column_names)
 	}
 }
 
@@ -252,6 +253,36 @@ func (qr *QueryResult) parseScalar(cell []interface{}) interface{} {
 	return s
 }
 
+func (qr *QueryResult) getStat(stat string) int {
+	if val, ok := qr.statistics[stat]; ok {
+		return int(val)
+	} else {
+		return 0
+	}
+}
+
+// Next returns true only if there is a record to be processed.
+func (qr *QueryResult) Next() bool {
+	if qr.Empty() {
+		return false
+	}
+	if qr.current_record_idx < len(qr.results)-1 {
+		qr.current_record_idx++
+		return true
+	} else {
+		return false
+	}
+}
+
+// Record returns the current record.
+func (qr *QueryResult) Record() *Record {
+	if qr.current_record_idx >= 0 && qr.current_record_idx < len(qr.results) {
+		return qr.results[qr.current_record_idx]
+	} else {
+		return nil
+	}
+}
+
 // PrettyPrint prints the QueryResult to stdout, pretty-like.
 func (qr *QueryResult) PrettyPrint() {
 	if qr.Empty() {
@@ -261,13 +292,14 @@ func (qr *QueryResult) PrettyPrint() {
 	table := tablewriter.NewWriter(os.Stdout)
 	table.SetAutoFormatHeaders(false)
 	table.SetHeader(qr.header.column_names)
-
+	row_count := len(qr.results)
+	col_count := len(qr.header.column_names)
 	if len(qr.results) > 0 {
 		// Convert to [][]string.
-		results := make([][]string, len(qr.results))
+		results := make([][]string, row_count)
 		for i, record := range qr.results {
-			results[i] = make([]string, len(record))
-			for j, elem := range record {
+			results[i] = make([]string, col_count)
+			for j, elem := range record.Values() {
 				results[i][j] = fmt.Sprint(elem)
 			}
 		}
@@ -284,14 +316,6 @@ 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)
 }

record.go

@@ -0,0 +1,41 @@
+package redisgraph
+
+type Record struct {
+	values	[]interface{}
+	keys	[]string
+}
+
+func recordNew(values []interface{}, keys []string) *Record {
+	r := &Record {
+		values: values,
+		keys: keys,
+	}
+
+	return r
+}
+
+func (r *Record) Keys() []string {
+	return r.keys
+}
+
+func (r *Record) Values() []interface{} {
+	return r.values
+}
+
+func (r *Record) Get(key string) (interface{}, bool) {
+	// TODO: switch from []string to map[string]int
+	for i := range r.keys {
+		if r.keys[i] == key {
+			return r.values[i], true
+		}
+	}
+	return nil, false
+}
+
+func (r *Record) GetByIndex(index int) interface{} {
+	if(index < len(r.values)) {
+		return r.values[index]
+	} else {
+		return nil
+	}
+}