From 0f51629cd2dd0beabd809787453d041ea0d1a25c Mon Sep 17 00:00:00 2001 From: Meng-Ying Yang Date: Tue, 25 Dec 2018 16:51:08 +0800 Subject: 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. --- core/types/block.go | 27 +++++++++++++- core/types/block_test.go | 93 ++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 112 insertions(+), 8 deletions(-) (limited to 'core') diff --git a/core/types/block.go b/core/types/block.go index 23da3ea77..96df245b7 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -18,7 +18,9 @@ package types import ( + "database/sql/driver" "encoding/binary" + "fmt" "io" "math/big" "sort" @@ -37,10 +39,15 @@ var ( EmptyUncleHash = CalcUncleHash(nil) ) +const ( + // Length of block nonce in bytes. + BlockNonceLength = 8 +) + // A BlockNonce is a 64-bit hash which proves (combined with the // mix-hash) that a sufficient amount of computation has been carried // out on a block. -type BlockNonce [8]byte +type BlockNonce [BlockNonceLength]byte // EncodeNonce converts the given integer to a block nonce. func EncodeNonce(i uint64) BlockNonce { @@ -64,6 +71,24 @@ func (n *BlockNonce) UnmarshalText(input []byte) error { return hexutil.UnmarshalFixedText("BlockNonce", input, n[:]) } +// Scan implements Scanner for database/sql. +func (n *BlockNonce) Scan(src interface{}) error { + srcB, ok := src.([]byte) + if !ok { + return fmt.Errorf("can't scan %T into BlockNonce", src) + } + if len(srcB) != BlockNonceLength { + return fmt.Errorf("can't scan []byte of len %d into BlockNonce, want %d", len(srcB), BlockNonceLength) + } + copy(n[:], srcB) + return nil +} + +// Value implements valuer for database/sql. +func (n BlockNonce) Value() (driver.Value, error) { + return n[:], nil +} + // WitnessData represents the witness data. type WitnessData struct { Root common.Hash diff --git a/core/types/block_test.go b/core/types/block_test.go index b2ac5485c..8e1165a99 100644 --- a/core/types/block_test.go +++ b/core/types/block_test.go @@ -16,18 +16,14 @@ package types -/* import ( - "bytes" - "fmt" - "math/big" + "database/sql/driver" "reflect" "testing" - - "github.com/dexon-foundation/dexon/common" - "github.com/dexon-foundation/dexon/rlp" ) +/* + // from bcValidBlockTest.json, "SimpleTx" func TestBlockEncoding(t *testing.T) { blockEnc := common.FromHex("f90260f901f9a083cafc574e1f51ba9dc0568fc617a08ea2429fb384059c972f13b19fa1c8dd55a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347948888f1f195afa192cfee860698584c030f4c9db1a0ef1552a40b7165c3cd773806b9e0c165b75356e0314bf0706f279c729f51e017a05fe50b260da6308036625b850b5d6ced6d0a9f814c0688bc91ffb7b7a3a54b67a0bc37d79753ad738a6dac4921e57392f145d8887476de3f783dfa7edae9283e52b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000001832fefd8825208845506eb0780a0bd4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff49888a13a5a8c8f2bb1c4f861f85f800a82c35094095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba09bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094fa08a8fae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b1c0") @@ -70,3 +66,86 @@ func TestBlockEncoding(t *testing.T) { } } */ + +func TestBlockNonce_Scan(t *testing.T) { + type args struct { + src interface{} + } + tests := []struct { + name string + args args + wantErr bool + }{ + { + name: "working scan", + args: args{src: []byte{ + 0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, + }}, + wantErr: false, + }, + { + name: "non working scan", + args: args{src: int64(1234567890)}, + wantErr: true, + }, + { + name: "invalid length scan", + args: args{src: []byte{ + 0xb2, 0x6f, 0x2b, 0x34, 0x2a, + }}, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + n := &BlockNonce{} + if err := n.Scan(tt.args.src); (err != nil) != tt.wantErr { + t.Errorf("BlockNonce.Scan() error = %v, wantErr %v", err, tt.wantErr) + } + + if !tt.wantErr { + for i := range n { + if n[i] != tt.args.src.([]byte)[i] { + t.Errorf( + "BlockNonce.Scan() didn't scan the %d src correctly (have %X, want %X)", + i, n[i], tt.args.src.([]byte)[i], + ) + } + } + } + }) + } +} + +func TestBlockNonce_Value(t *testing.T) { + b := []byte{ + 0xb2, 0x6f, 0x2b, 0x34, 0x2a, 0xab, 0x24, 0xbc, + } + var nonce BlockNonce + nonce.UnmarshalText([]byte("0xb26f2b342aab24bc")) + tests := []struct { + name string + n BlockNonce + want driver.Value + wantErr bool + }{ + { + name: "Working value", + n: nonce, + want: b, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.n.Value() + if (err != nil) != tt.wantErr { + t.Errorf("BlockNonce.Value() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("BlockNonce.Value() = %v, want %v", got, tt.want) + } + }) + } +} -- cgit v1.2.3