Merge branch 'release/v0.3'

Author: dancannon

CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## v0.2 (RethinkDB v1.12) - 13 April
+## v0.3 (RethinkDB v1.13) - 26 June 2014
+
+- Replaced `ResultRows`/`ResultRow` with `Cursor`, `Cursor` has the `Next`, `All` and `One` methods which stores the relevant value in the value pointed at by result. For more information check the examples.
+- Changed the time constants (Days and Months) to package globals instead of functions
+- Added the `Args` term and changed the arguments for many terms to `args ...interface{}` to allow argument splicing
+- Added the `Changes` term and support for the feed response type
+- Added the `Random` term
+- Added the `Http` term
+- The second argument for `Slice` is now optional
+- `EqJoin` now accepts a function as its first argument
+- `Nth` now returns a selection
+
+## v0.2 (RethinkDB v1.12) - 13 April 2014
 
 * Changed `Connect` to use `ConnectOpts` instead of `map[string]interface{}`
 * Migrated to new `Group`/`Ungroup` functions, these replace `GroupedMapReduce` and `GroupBy`
@@ -13,8 +25,8 @@
 
 ## v0.1 (RethinkDB v1.11) - 27 November 2013
 
- * Added noreply writes
- * Added the new terms `index_status`, `index_wait` and `sync`
- * Added the profile flag to the run functions
- * Optional arguments are now structs instead of key, pair strings. Almost all of the struct fields are of type interface{} as they can have terms inside them. For example: `r.TableCreateOpts{ PrimaryKey: r.Expr("index") }`
- * Returned arrays are now properly loaded into ResultRows. In the past when running `r.Expr([]interface{}{1,2,3})` would require you to use `RunRow` followed by `Scan`. You can now use `Run` followed by `ScanAll`
+* Added noreply writes
+* Added the new terms `index_status`, `index_wait` and `sync`
+* Added the profile flag to the run functions
+* Optional arguments are now structs instead of key, pair strings. Almost all of the struct fields are of type interface{} as they can have terms inside them. For example: `r.TableCreateOpts{ PrimaryKey: r.Expr("index") }`
+* Returned arrays are now properly loaded into ResultRows. In the past when running `r.Expr([]interface{}{1,2,3})` would require you to use `RunRow` followed by `Scan`. You can now use `Run` followed by `ScanAll`

README.md

@@ -3,9 +3,10 @@ GoRethink - RethinkDB Driver for Go [![wercker status](https://app.wercker.com/s
 
 [Go](http://golang.org/) driver for [RethinkDB](http://www.rethinkdb.com/) made by [Daniel Cannon](http://github.com/dancannon) and based off of Christopher Hesse's [RethinkGo](https://github.com/christopherhesse/rethinkgo) driver.
 
-Current version: v0.2.1 (RethinkDB v1.12) 
 
-**Version 0.2 introduced some BC breaking changes, for more information check the [change log](CHANGELOG.md)**
+Current version: v0.3 (RethinkDB v1.13) 
+
+**Version 0.3 introduced some API changes, for more information check the [change log](CHANGELOG.md)**
 
 ## Installation
 
@@ -67,36 +68,36 @@ A pre-configured [Pool](http://godoc.org/github.com/dancannon/gorethink#Pool) in
 
 This library is based on the official drivers so the code on the [API](http://www.rethinkdb.com/api/) page should require very few changes to work.
 
-To view full documentation for the query functions check the [GoDoc](http://godoc.org/github.com/dancannon/gorethink#RqlTerm)
+To view full documentation for the query functions check the [GoDoc](http://godoc.org/github.com/dancannon/gorethink#Term)
 
 Slice Expr Example
 ```go
-r.Expr([]interface{}{1, 2, 3, 4, 5}).RunRow(conn)
+r.Expr([]interface{}{1, 2, 3, 4, 5}).Run(session)
 ```
 Map Expr Example
 ```go
-r.Expr(map[string]interface{}{"a": 1, "b": 2, "c": 3}).RunRow(conn)
+r.Expr(map[string]interface{}{"a": 1, "b": 2, "c": 3}).Run(session)
 ```
 Get Example
 ```go
-r.Db("database").Table("table").Get("GUID").RunRow(conn)
+r.Db("database").Table("table").Get("GUID").Run(session)
 ```
 Map Example (Func)
 ```go
-r.Expr([]interface{}{1, 2, 3, 4, 5}).Map(func (row RqlTerm) RqlTerm {
+r.Expr([]interface{}{1, 2, 3, 4, 5}).Map(func (row Term) interface{} {
     return row.Add(1)
-}).Run(conn)
+}).Run(session)
 ```
 Map Example (Implicit)
 ```go
-r.Expr([]interface{}{1, 2, 3, 4, 5}).Map(r.Row.Add(1)).Run(conn)
+r.Expr([]interface{}{1, 2, 3, 4, 5}).Map(r.Row.Add(1)).Run(session)
 ```
 Between (Optional Args) Example
 ```go
 r.Db("database").Table("table").Between(1, 10, r.BetweenOpts{
     Index: "num",
     RightBound: "closed",
-}).Run(conn)
+}).Run(session)
 ```
 
 
@@ -108,42 +109,54 @@ As shown above in the Between example optional arguments are passed to the funct
 
 Different result types are returned depending on what function is used to execute the query.
 
-- Run returns a ResultRows type which can be used to view
+- `Run` returns a cursor which can be used to view
 all rows returned.
-- RunRow returns a single row and can be used for queries such as Get where only a single row should be returned(or none).
-- RunWrite returns a ResultRow scanned into WriteResponse and should be used for queries such as Insert,Update,etc...
-- Exec sends a query to the server with the noreply flag set and returns immediately
-
-Both ResultRows and ResultRow have the function `Scan` which is used to bind a row to a variable.
+- `RunWrite` returns a WriteResponse and should be used for queries such as Insert,Update,etc...
+- `Exec` sends a query to the server with the noreply flag set and returns immediately
 
 Example:
 
 ```go
-row, err := Table("tablename").Get(key).RunRow(conn)
+res, err := Table("tablename").Get(key).Run(session)
 if err != nil {
-	// error
-}
-// Check if something was found
-if !row.IsNil() {
-	var response interface{}
-	err := row.Scan(&response)
+    // error
 }
 ```
 
-ResultRows also has the function `Next` which is used to iterate through a result set. If a partial sequence is returned by the server Next will automatically fetch the result of the sequence.
+Cursors have a number of methods available for accessing the query results
 
-Example:
+- `Next` retrieves the next document from the result set, blocking if necessary.
+- `All` retrieves all documents from the result set into the provided slice.
+- `One` retrieves the first document from the result se.
+
+Examples:
+
+```go
+var row interface{}
+for res.Next(&result) {
+    // Do something with row
+}
+if res.Err() != nil {
+    // error
+}
+```
 
 ```go
-rows, err := Table("tablename").Run(conn)
+var rows []interface{}
+err := res.All(&rows)
 if err != nil {
-	// error
+    // error
 }
-for rows.Next() {
-    var row interface{}
-    err := rows.Scan(&row)
+```
 
-    // Do something with row
+```go
+var row interface{}
+err := res.One(&row)
+if err == r.ErrEmptyResult {
+    // row not found
+}
+if err != nil {
+    // error
 }
 ```
 

connection.go

@@ -13,7 +13,7 @@ import (
 )
 
 type Conn interface {
-	SendQuery(s *Session, q *p.Query, t RqlTerm, opts map[string]interface{}, async bool) (*ResultRows, error)
+	SendQuery(s *Session, q *p.Query, t Term, opts map[string]interface{}, async bool) (*Cursor, error)
 	ReadResponse(s *Session, token int64) (*p.Response, error)
 	Close() error
 }
@@ -27,23 +27,33 @@ type Connection struct {
 	closed bool
 }
 
-// Reconnect closes the previous connection and attempts to connect again.
+// Dial closes the previous connection and attempts to connect again.
 func Dial(s *Session) (*Connection, error) {
 	conn, err := net.Dial("tcp", s.address)
 	if err != nil {
 		return nil, RqlConnectionError{err.Error()}
 	}
 
-	if err := binary.Write(conn, binary.LittleEndian, p.VersionDummy_V0_2); err != nil {
+	// Send the protocol version to the server as a 4-byte little-endian-encoded integer
+	if err := binary.Write(conn, binary.LittleEndian, p.VersionDummy_V0_3); err != nil {
 		return nil, RqlConnectionError{err.Error()}
 	}
 
-	// authorization key
+	// Send the length of the auth key to the server as a 4-byte little-endian-encoded integer
 	if err := binary.Write(conn, binary.LittleEndian, uint32(len(s.authkey))); err != nil {
 		return nil, RqlConnectionError{err.Error()}
 	}
 
-	if err := binary.Write(conn, binary.BigEndian, []byte(s.authkey)); err != nil {
+	// Send the auth key as an ASCII string
+	// If there is no auth key, skip this step
+	if s.authkey != "" {
+		if _, err := io.WriteString(conn, s.authkey); err != nil {
+			return nil, RqlConnectionError{err.Error()}
+		}
+	}
+
+	// Send the protocol type as a 4-byte little-endian-encoded integer
+	if err := binary.Write(conn, binary.LittleEndian, p.VersionDummy_PROTOBUF); err != nil {
 		return nil, RqlConnectionError{err.Error()}
 	}
 
@@ -111,7 +121,7 @@ func (c *Connection) ReadResponse(s *Session, token int64) (*p.Response, error)
 	}
 }
 
-func (c *Connection) SendQuery(s *Session, q *p.Query, t RqlTerm, opts map[string]interface{}, async bool) (*ResultRows, error) {
+func (c *Connection) SendQuery(s *Session, q *p.Query, t Term, opts map[string]interface{}, async bool) (*Cursor, error) {
 	var data []byte
 	var err error
 
@@ -170,24 +180,26 @@ func (c *Connection) SendQuery(s *Session, q *p.Query, t RqlTerm, opts map[strin
 		}
 	}
 
-	// De-construct datum and return the result
+	// De-construct datum and return a cursor
 	switch response.GetType() {
-	case p.Response_SUCCESS_PARTIAL, p.Response_SUCCESS_SEQUENCE:
-		result := &ResultRows{
+	case p.Response_SUCCESS_PARTIAL, p.Response_SUCCESS_SEQUENCE, p.Response_SUCCESS_FEED:
+		cursor := &Cursor{
 			session: s,
 			query:   q,
 			term:    t,
 			opts:    opts,
 			profile: profile,
+			timeout: -1,
 		}
+		cursor.gotReply.L = &cursor.mu
 
 		s.Lock()
-		s.cache[*q.Token] = result
+		s.cache[*q.Token] = cursor
 		s.Unlock()
 
-		result.extend(response)
+		cursor.extend(response)
 
-		return result, nil
+		return cursor, nil
 	case p.Response_SUCCESS_ATOM:
 		var value []interface{}
 		var err error
@@ -216,15 +228,19 @@ func (c *Connection) SendQuery(s *Session, q *p.Query, t RqlTerm, opts map[strin
 			}
 		}
 
-		return &ResultRows{
+		cursor := &Cursor{
 			session:  s,
 			query:    q,
 			term:     t,
 			opts:     opts,
 			profile:  profile,
 			buffer:   value,
 			finished: true,
-		}, nil
+			timeout:  -1,
+		}
+		cursor.gotReply.L = &cursor.mu
+
+		return cursor, nil
 	case p.Response_WAIT_COMPLETE:
 		return nil, nil
 	default:
@@ -237,7 +253,7 @@ func (c *Connection) Close() error {
 	return c.Conn.Close()
 }
 
-func checkErrorResponse(response *p.Response, t RqlTerm) error {
+func checkErrorResponse(response *p.Response, t Term) error {
 	switch response.GetType() {
 	case p.Response_CLIENT_ERROR:
 		return RqlClientError{rqlResponseError{response, t}}

datum.go

@@ -11,7 +11,7 @@ import (
 
 // Converts a query term to a datum. If the term cannot be converted to a datum
 // object then the function panics.
-func constructDatum(t RqlTerm) (*p.Term, error) {
+func constructDatum(t Term) (*p.Term, error) {
 	if t.data == nil {
 		return &p.Term{
 			Type: p.Term_DATUM.Enum(),

doc.go

@@ -1,6 +1,6 @@
 // Go driver for RethinkDB
 //
-// Current version: v0.2.1 (RethinkDB v1.12)
+// Current version: v0.3 (RethinkDB v1.13)
 // For more in depth information on how to use RethinkDB check out the API docs
 // at http://rethinkdb.com/api
 package gorethink

errors.go

@@ -2,12 +2,13 @@ package gorethink
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 
 	p "github.com/dancannon/gorethink/ql2"
 )
 
-func printCarrots(t RqlTerm, frames []*p.Frame) string {
+func printCarrots(t Term, frames []*p.Frame) string {
 	var frame *p.Frame
 	if len(frames) > 1 {
 		frame, frames = frames[0], frames[1:]
@@ -17,7 +18,7 @@ func printCarrots(t RqlTerm, frames []*p.Frame) string {
 
 	for i, arg := range t.args {
 		if frame.GetPos() == int64(i) {
-			t.args[i] = RqlTerm{
+			t.args[i] = Term{
 				termType: p.Term_DATUM,
 				data:     printCarrots(arg, frames),
 			}
@@ -26,7 +27,7 @@ func printCarrots(t RqlTerm, frames []*p.Frame) string {
 
 	for k, arg := range t.optArgs {
 		if frame.GetOpt() == k {
-			t.optArgs[k] = RqlTerm{
+			t.optArgs[k] = Term{
 				termType: p.Term_DATUM,
 				data:     printCarrots(arg, frames),
 			}
@@ -45,11 +46,14 @@ func printCarrots(t RqlTerm, frames []*p.Frame) string {
 	return b.String()
 }
 
+// Error constants
+var ErrEmptyResult = errors.New("The result does not contain any more rows")
+
 // Connection/Response errors
-// ----------------------------------------------------------------------------
+
 type rqlResponseError struct {
 	response *p.Response
-	term     RqlTerm
+	term     Term
 }
 
 func (e rqlResponseError) Error() string {