Fixing a conversion bug with int64 and time.Duration.

mysql/mysql_test.go

@@ -73,7 +73,7 @@ func TestOpenFailed(t *testing.T) {
 	_, err := db.Open(wrapperName, db.DataSource{})
 
 	if err == nil {
-		t.Errorf("Could not open database.")
+		t.Fatalf("Could not open database.")
 	}
 }
 
@@ -103,7 +103,7 @@ func TestTruncate(t *testing.T) {
 		}
 
 		if total != 0 {
-			t.Errorf("Could not truncate.")
+			t.Fatalf("Could not truncate.")
 		}
 	}
 
@@ -422,7 +422,7 @@ func TestPopulate(t *testing.T) {
 	sess, err := db.Open(wrapperName, settings)
 
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Fatalf(err.Error())
 	}
 
 	defer sess.Close()
@@ -482,7 +482,7 @@ func TestRelation(t *testing.T) {
 	sess, err := db.Open(wrapperName, settings)
 
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Fatalf(err.Error())
 	}
 
 	defer sess.Close()
@@ -539,7 +539,7 @@ func TestRelationStruct(t *testing.T) {
 	sess, err := db.Open(wrapperName, settings)
 
 	if err != nil {
-		t.Errorf(err.Error())
+		t.Fatalf(err.Error())
 	}
 
 	defer sess.Close()
@@ -632,7 +632,7 @@ func TestDataTypes(t *testing.T) {
 	}
 
 	if found == 0 {
-		t.Errorf("Expecting an item.")
+		t.Fatalf("Expecting an item.")
 	}
 
 	// Getting and reinserting (a db.Item).
@@ -695,7 +695,7 @@ func TestDataTypes(t *testing.T) {
 	// Testing struct equality
 	for _, item := range sresults {
 		if reflect.DeepEqual(item, testValues) == false {
-			t.Errorf("Struct is different.")
+			t.Fatalf("Struct is different.")
 		}
 	}
 

util/main.go

@@ -34,6 +34,12 @@ import (
 	"time"
 )
 
+var (
+	ErrExpectingPointer        = errors.New(`Expecting a pointer destination (dst interface{}).`)
+	ErrExpectingSlicePointer   = errors.New(`Expecting a pointer to an slice (dst interface{}).`)
+	ErrExpectingSliceMapStruct = errors.New(`Expecting a pointer to an slice of maps or structs (dst interface{}).`)
+)
+
 var extRelationPattern = regexp.MustCompile(`\{(.+)\}`)
 var columnCompareExclude = regexp.MustCompile(`[^a-zA-Z0-9]`)
 
@@ -305,7 +311,7 @@ func (self *C) FetchRelation(dst interface{}, relations []db.Relation, convertFn
 	dstv := reflect.ValueOf(dst)
 
 	if dstv.Kind() != reflect.Ptr || dstv.IsNil() {
-		return errors.New("Expecting a pointer.")
+		return ErrExpectingPointer
 	}
 
 	err = fetchItemRelations(dstv.Elem(), relations, convertFn)
@@ -350,21 +356,39 @@ func ValidateSliceDestination(dst interface{}) error {
 	// Checking input
 	dstv = reflect.ValueOf(dst)
 
-	if dstv.Kind() != reflect.Ptr || dstv.IsNil() || dstv.Elem().Kind() != reflect.Slice {
-		return errors.New("Expecting a pointer to slice.")
+	if dstv.IsNil() || dstv.Kind() != reflect.Ptr {
+		return ErrExpectingPointer
+	}
+
+	if dstv.Elem().Kind() != reflect.Slice {
+		return ErrExpectingSlicePointer
 	}
 
 	itemv = dstv.Elem()
 	itemk = itemv.Type().Elem().Kind()
 
 	if itemk != reflect.Struct && itemk != reflect.Map {
-		return errors.New("Expecting a pointer to slice of maps or structs.")
+		return ErrExpectingSliceMapStruct
 	}
 
 	return nil
 }
 
-func ConvertValue(src string, dstk reflect.Kind) (reflect.Value, error) {
+func StringToType(src string, dstt reflect.Type) (reflect.Value, error) {
+	var srcv reflect.Value
+	switch dstt {
+	case durationType:
+		srcv = reflect.ValueOf(to.Duration(src))
+	case timeType:
+		// Destination is time.Time
+		srcv = reflect.ValueOf(to.Time(src))
+	default:
+		return StringToKind(src, dstt.Kind())
+	}
+	return srcv, nil
+}
+
+func StringToKind(src string, dstk reflect.Kind) (reflect.Value, error) {
 	var srcv reflect.Value
 
 	// Destination type.
@@ -372,15 +396,11 @@ func ConvertValue(src string, dstk reflect.Kind) (reflect.Value, error) {
 	case reflect.Interface:
 		// Destination is interface, nuff said.
 		srcv = reflect.ValueOf(src)
-	case durationType.Kind():
-		// Destination is time.Duration
-		srcv = reflect.ValueOf(to.Duration(src))
-	case timeType.Kind():
-		// Destination is time.Time
-		srcv = reflect.ValueOf(to.Time(src))
 	default:
-		// Destination is of an unknown type.
-		cv, _ := to.Convert(src, dstk)
+		cv, err := to.Convert(src, dstk)
+		if err != nil {
+			return srcv, nil
+		}
 		srcv = reflect.ValueOf(cv)
 	}
 

util/sqlutil/main.go

@@ -34,6 +34,10 @@ import (
 	"strings"
 )
 
+var (
+	ErrNoMoreRows = errors.New(`There are no more rows in this result set.`)
+)
+
 type T struct {
 	PrimaryKey  string
 	ColumnTypes map[string]reflect.Kind
@@ -103,21 +107,18 @@ func (self *T) fetchResult(itemt reflect.Type, rows *sql.Rows, columns []string)
 			var cv reflect.Value
 
 			if _, ok := self.ColumnTypes[column]; ok == true {
-				v, _ := to.Convert(string(*value), self.ColumnTypes[column])
+				v, _ := to.Convert(svalue, self.ColumnTypes[column])
 				cv = reflect.ValueOf(v)
 			} else {
-				v, _ := to.Convert(string(*value), reflect.String)
+				v, _ := to.Convert(svalue, reflect.String)
 				cv = reflect.ValueOf(v)
 			}
 
 			switch itemt.Kind() {
 			// Destination is a map.
 			case reflect.Map:
-				if cv.Type().Kind() != itemt.Elem().Kind() {
-					if itemt.Elem().Kind() != reflect.Interface {
-						// Converting value.
-						cv, _ = util.ConvertValue(svalue, itemt.Elem().Kind())
-					}
+				if cv.Type() != itemt.Elem() {
+					cv, _ = util.StringToType(svalue, itemt.Elem())
 				}
 				if cv.IsValid() {
 					item.SetMapIndex(reflect.ValueOf(column), cv)
@@ -135,10 +136,9 @@ func (self *T) fetchResult(itemt reflect.Type, rows *sql.Rows, columns []string)
 					destf := item.Elem().FieldByIndex(index)
 
 					if destf.IsValid() {
-						if cv.Type().Kind() != destf.Type().Kind() {
+						if cv.Type() != destf.Type() {
 							if destf.Type().Kind() != reflect.Interface {
-								// Converting value.
-								cv, _ = util.ConvertValue(svalue, destf.Type().Kind())
+								cv, _ = util.StringToType(svalue, destf.Type())
 							}
 						}
 						// Copying value.
@@ -178,8 +178,8 @@ func (self *T) FetchRow(dst interface{}, rows *sql.Rows) error {
 
 	dstv := reflect.ValueOf(dst)
 
-	if dstv.Kind() != reflect.Ptr || dstv.IsNil() {
-		return errors.New("fetchRows expects a pointer to slice.")
+	if dstv.IsNil() || dstv.Kind() != reflect.Ptr {
+		return util.ErrExpectingPointer
 	}
 
 	itemv := dstv.Elem()
@@ -193,7 +193,7 @@ func (self *T) FetchRow(dst interface{}, rows *sql.Rows) error {
 	next := rows.Next()
 
 	if next == false {
-		return fmt.Errorf("No more rows.")
+		return ErrNoMoreRows
 	}
 
 	item, err := self.fetchResult(itemv.Type(), rows, columns)
@@ -215,8 +215,16 @@ func (self *T) FetchRows(dst interface{}, rows *sql.Rows) error {
 	// Destination.
 	dstv := reflect.ValueOf(dst)
 
+	if dstv.IsNil() || dstv.Kind() != reflect.Ptr {
+		return util.ErrExpectingPointer
+	}
+
+	if dstv.Elem().Kind() != reflect.Slice {
+		return util.ErrExpectingSlicePointer
+	}
+
 	if dstv.Kind() != reflect.Ptr || dstv.Elem().Kind() != reflect.Slice || dstv.IsNil() {
-		return errors.New("Expecting a pointer to slice of maps or structs.")
+		return util.ErrExpectingSliceMapStruct
 	}
 
 	columns, err := getRowColumns(rows)