added fetch/extra conversion functions

Author: Phil Bayfield

convert.go

@@ -213,6 +213,48 @@ func lcbtob(n uint64) (b []byte) {
 	// <= 0xffffff = 253 + 3 bytes
 	case n <= 0xffffff:
 		b = []byte{0xfd, byte(n), byte(n >> 8), byte(n >> 16)}
+	// Due to max packet size the 8 byte version is never actually used so is ommited
+	}
+	return
+}
+
+// any to uint64
+func atou64(i interface{}) (n uint64) {
+	switch t := i.(type) {
+	case int: n = uint64(t)
+	case uint: n = uint64(t)
+	case int8: n = uint64(t)
+	case uint8: n = uint64(t)
+	case int16: n = uint64(t)
+	case uint16: n = uint64(t)
+	case int32: n = uint64(t)
+	case uint32: n = uint64(t)
+	case int64: n = uint64(t)
+	case uint64: return t
+	default:
+		panic("Not a numeric type")
+	}
+	return
+}
+
+// any to float64
+func atof64(i interface{}) (f float64) {
+	switch t := i.(type) {
+	case float32: f = float64(t)
+	case float64: return t
+	default:
+		panic("Not a floating point type")
+	}
+	return
+}
+
+// any to string
+func atos(i interface{}) (s string) {
+	switch t:= i.(type) {
+	case []byte: s = string(t)
+	case string: return t
+	default:
+		panic("Not a string or compatible type")
 	}
 	return
 }

handler.go

@@ -177,67 +177,68 @@ func handleBinaryRow(p *packetRowBinary, c *Client, r *Result) (err os.Error) {
 	}
 	// Read data into fields
 	var row []interface{}
+	var field interface{}
 	// Get null bit map
 	nc := (r.fieldCount + 9) / 8
-	nbm := p.data[0:nc]
-	pos := nc
+	nbm := p.data[1:nc+1]
+	pos := nc + 1
 	for i, f := range r.fields {
 		// Check if field is null
 		posByte := (i + 2) / 8
 		posBit := i - (posByte * 8) + 2
 		if nbm[posByte]&(1<<uint8(posBit)) != 0 {
-			row = append(row, nil)
+			field = nil
 			continue
 		}
 		// Otherwise use field type
 		switch f.Type {
 		// Tiny int (8 bit int unsigned or signed)
 		case FIELD_TYPE_TINY:
 			if f.Flags&FLAG_UNSIGNED > 0 {
-				row = append(row, p.data[pos])
+				field = p.data[pos]
 			} else {
-				row = append(row, int8(p.data[pos]))
+				field = int8(p.data[pos])
 			}
 			pos++
 		// Small int (16 bit int unsigned or signed)
 		case FIELD_TYPE_SHORT, FIELD_TYPE_YEAR:
 			if f.Flags&FLAG_UNSIGNED > 0 {
-				row = append(row, btoui16(p.data[pos:pos+2]))
+				field = btoui16(p.data[pos:pos+2])
 			} else {
-				row = append(row, btoi16(p.data[pos:pos+2]))
+				field = btoi16(p.data[pos:pos+2])
 			}
 			pos += 2
 		// Int (32 bit int unsigned or signed) and medium int which is actually in int32 format
 		case FIELD_TYPE_LONG, FIELD_TYPE_INT24:
 			if f.Flags&FLAG_UNSIGNED > 0 {
-				row = append(row, btoui32(p.data[pos:pos+4]))
+				field = btoui32(p.data[pos:pos+4])
 			} else {
-				row = append(row, btoi32(p.data[pos:pos+4]))
+				field = btoi32(p.data[pos:pos+4])
 			}
 			pos += 4
 		// Big int (64 bit int unsigned or signed)
 		case FIELD_TYPE_LONGLONG:
 			if f.Flags&FLAG_UNSIGNED > 0 {
-				row = append(row, btoui64(p.data[pos:pos+8]))
+				field = btoui64(p.data[pos:pos+8])
 			} else {
-				row = append(row, btoi64(p.data[pos:pos+8]))
+				field = btoi64(p.data[pos:pos+8])
 			}
 			pos += 8
 		// Floats (Single precision floating point, 32 bit signed)
 		case FIELD_TYPE_FLOAT:
-			row = append(row, btof32(p.data[pos:pos+4]))
+			field = btof32(p.data[pos:pos+4])
 			pos += 4
 		// Double (Double precision floating point, 64 bit signed)
 		case FIELD_TYPE_DOUBLE:
-			row = append(row, btof64(p.data[pos:pos+8]))
+			field = btof64(p.data[pos:pos+8])
 			pos += 8
 		// Bit, decimal, strings, blobs etc, all length coded binary strings
 		case FIELD_TYPE_BIT, FIELD_TYPE_DECIMAL, FIELD_TYPE_NEWDECIMAL, FIELD_TYPE_VARCHAR, FIELD_TYPE_TINY_BLOB, FIELD_TYPE_MEDIUM_BLOB, FIELD_TYPE_LONG_BLOB, FIELD_TYPE_BLOB, FIELD_TYPE_VAR_STRING, FIELD_TYPE_STRING, FIELD_TYPE_GEOMETRY:
 			num, n, err := btolcb(p.data[pos:])
 			if err != nil {
 				return
 			}
-			row = append(row, p.data[pos+uint64(n):pos+uint64(n)+num])
+			field = p.data[pos+uint64(n):pos+uint64(n)+num]
 			pos += uint64(n) + num
 		// Date/Datetime/Timestamp YYYY-MM-DD HH:MM:SS (From libmysql/libmysql.c read_binary_datetime)
 		case FIELD_TYPE_DATE, FIELD_TYPE_TIMESTAMP, FIELD_TYPE_DATETIME:
@@ -246,6 +247,8 @@ func handleBinaryRow(p *packetRowBinary, c *Client, r *Result) (err os.Error) {
 		case FIELD_TYPE_TIME:
 			// @todo
 		}
+		// Add to row
+		row = append(row, field)
 	}
 	// Stored result
 	if r.mode == RESULT_STORED {

mysql.go

@@ -332,6 +332,8 @@ func (c *Client) NextResult() (more bool, err os.Error) {
 	// Read result from server
 	c.sequence++
 	_, err = c.getResult(PACKET_OK | PACKET_ERROR | PACKET_RESULT)
+	// Store fields
+	err = c.getFields()
 	return
 }
 

statement.go

@@ -6,10 +6,10 @@
 package mysql
 
 import (
+	"fmt"
 	"os"
 	"reflect"
 	"strconv"
-	"fmt"
 )
 
 // Prepared statement struct
@@ -38,6 +38,7 @@ type Statement struct {
 	LastInsertId uint64
 	Warnings     uint16
 	result       *Result
+	resultParams []interface{}
 }
 
 // Prepare new statement
@@ -296,11 +297,82 @@ func (s *Statement) Execute() (err os.Error) {
 
 // Bind result
 func (s *Statement) BindResult(params ...interface{}) (err os.Error) {
+	s.resultParams = params
 	return
 }
 
 // Fetch next row 
-func (s *Statement) Fetch() (err os.Error) {
+func (s *Statement) Fetch() (eof bool, err os.Error) {
+	// Log fetch
+	s.c.log(1, "=== Begin fetch ===")
+	// Check result
+	if !s.checkResult() {
+		return false, &ClientError{CR_NO_RESULT_SET, CR_NO_RESULT_SET_STR}
+	}
+	var row Row
+	// Check result mode
+	switch s.result.mode{
+	// Used or unused result (needs fetching)
+	case RESULT_UNUSED, RESULT_USED:
+		s.result.mode = RESULT_USED
+		if s.result.allRead == true {
+			return true, nil
+		}
+		eof, err := s.getRow()
+		if err != nil {
+			return false, err
+		}
+		if eof {
+			s.result.allRead = true
+		}
+		row = s.result.rows[0]
+	// Stored result
+	case RESULT_STORED:
+		if s.result.rowPos >= uint64(len(s.result.rows)) {
+			return true, nil
+		}
+		row = s.result.rows[s.result.rowPos]
+		s.result.rowPos ++
+	}
+	// Recover possible errors from type conversion
+	defer func() {
+		if e := recover(); e != nil {
+			err = &ClientError{CR_UNKNOWN_ERROR, CR_UNKNOWN_ERROR_STR}
+		}
+	}()
+	// Iterate bound params and assign from row (partial set quicker this way)
+	for k, v := range s.resultParams {
+		switch t := v.(type) {
+		case *int:
+			*t = int(atou64(row[k]))
+		case *uint:
+			*t = uint(atou64(row[k]))
+		case *int8:
+			*t = int8(atou64(row[k]))
+		case *uint8:
+			*t = uint8(atou64(row[k]))
+		case *int16:
+			*t = int16(atou64(row[k]))
+		case *uint16:
+			*t = uint16(atou64(row[k]))
+		case *int32:
+			*t = int32(atou64(row[k]))
+		case *uint32:
+			*t = uint32(atou64(row[k]))
+		case *int64:
+			*t = int64(atou64(row[k]))
+		case *uint64:
+			*t = atou64(row[k])
+		case *float32:
+			*t = float32(atof64(row[k]))
+		case *float64:
+			*t = atof64(row[k])
+		case *[]byte:
+			*t = row[k].([]byte)
+		case *string:
+			*t = atos(row[k])
+		}
+	}
 	return
 }
 
@@ -347,6 +419,14 @@ func (s *Statement) reset() {
 	s.c.reset()
 }
 
+// Check if a result exists
+func (s *Statement) checkResult() bool {
+	if s.result != nil {
+		return true
+	}
+	return false
+}
+
 // Get null bit map
 func (s *Statement) getNullBitMap() (nbm []byte) {
 	nbm = make([]byte, (s.paramCount+7)/8)