core: add database/sql support for more types (#102)

* core: types: add database/sql support for BlockNonce

* common: add database/sql support with Big

New Big type is declared to let big.Int support database/sql by
implementing Scan() and Value() on new type.

2 files changed, 131 insertions, 1 deletions

diff --git a/common/big.go b/common/big.go
index 65d4377bf..dcc5269a7 100644
--- a/common/big.go
+++ b/common/big.go
@@ -16,7 +16,11 @@
 
 package common
 
-import "math/big"
+import (
+	"database/sql/driver"
+	"fmt"
+	"math/big"
+)
 
 // Common big integers often used
 var (
@@ -28,3 +32,34 @@ var (
 	Big256 = big.NewInt(256)
 	Big257 = big.NewInt(257)
 )
+
+// Big support database/sql Scan and Value.
+type Big big.Int
+
+// Scan implements Scanner for database/sql.
+func (b *Big) Scan(src interface{}) error {
+	newB := new(big.Int)
+	switch t := src.(type) {
+	case int64:
+		*b = Big(*newB.SetInt64(t))
+	case uint64:
+		*b = Big(*newB.SetUint64(t))
+	case []byte:
+		*b = Big(*newB.SetBytes(t))
+	case string:
+		v, ok := newB.SetString(t, 10)
+		if !ok {
+			return fmt.Errorf("invalid string format %v", src)
+		}
+		*b = Big(*v)
+	default:
+		return fmt.Errorf("can't scan %T into Big", src)
+	}
+	return nil
+}
+
+// Value implements valuer for database/sql.
+func (b Big) Value() (driver.Value, error) {
+	b2 := big.Int(b)
+	return (&b2).String(), nil
+}
diff --git a/common/big_test.go b/common/big_test.go
new file mode 100644
index 000000000..0339b4760
--- /dev/null
+++ b/common/big_test.go
@@ -0,0 +1,95 @@
+package common
+
+import (
+	"database/sql/driver"
+	"math/big"
+	"reflect"
+	"testing"
+)
+
+func TestBig_Scan(t *testing.T) {
+	type args struct {
+		src interface{}
+	}
+	tests := []struct {
+		name    string
+		args    args
+		value   Big
+		wantErr bool
+	}{
+		{
+			name:    "scan int64",
+			args:    args{src: int64(-10)},
+			value:   Big(*big.NewInt(-10)),
+			wantErr: false,
+		},
+		{
+			name:    "scan uint64",
+			args:    args{src: uint64(10)},
+			value:   Big(*big.NewInt(10)),
+			wantErr: false,
+		},
+		{
+			name:    "scan bytes",
+			args:    args{src: []byte{0x0a}},
+			value:   Big(*big.NewInt(10)),
+			wantErr: false,
+		},
+		{
+			name:    "scan string",
+			args:    args{src: "-10"},
+			value:   Big(*big.NewInt(-10)),
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b := &Big{}
+			if err := b.Scan(tt.args.src); (err != nil) != tt.wantErr {
+				t.Errorf("Big.Scan() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			if !tt.wantErr {
+				if !reflect.DeepEqual(*b, tt.value) {
+					t.Errorf(
+						"Big.Scan() wrong value (got: %v, want: %v)",
+						*b, tt.value,
+					)
+				}
+			}
+		})
+	}
+
+}
+func TestBig_Value(t *testing.T) {
+	r := "12345"
+	b := Big(*big.NewInt(12345))
+	tests := []struct {
+		name    string
+		b       Big
+		want    driver.Value
+		wantErr bool
+	}{
+		{
+			name:    "working value",
+			b:       b,
+			want:    r,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.b.Value()
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Big.Value() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Hash.Value() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}