...
Run Format

Source file src/database/sql/convert_test.go

Documentation: database/sql

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package sql
     6  
     7  import (
     8  	"database/sql/driver"
     9  	"fmt"
    10  	"reflect"
    11  	"runtime"
    12  	"strings"
    13  	"sync"
    14  	"testing"
    15  	"time"
    16  )
    17  
    18  var someTime = time.Unix(123, 0)
    19  var answer int64 = 42
    20  
    21  type (
    22  	userDefined       float64
    23  	userDefinedSlice  []int
    24  	userDefinedString string
    25  )
    26  
    27  type conversionTest struct {
    28  	s, d interface{} // source and destination
    29  
    30  	// following are used if they're non-zero
    31  	wantint    int64
    32  	wantuint   uint64
    33  	wantstr    string
    34  	wantbytes  []byte
    35  	wantraw    RawBytes
    36  	wantf32    float32
    37  	wantf64    float64
    38  	wanttime   time.Time
    39  	wantbool   bool // used if d is of type *bool
    40  	wanterr    string
    41  	wantiface  interface{}
    42  	wantptr    *int64 // if non-nil, *d's pointed value must be equal to *wantptr
    43  	wantnil    bool   // if true, *d must be *int64(nil)
    44  	wantusrdef userDefined
    45  	wantusrstr userDefinedString
    46  }
    47  
    48  // Target variables for scanning into.
    49  var (
    50  	scanstr    string
    51  	scanbytes  []byte
    52  	scanraw    RawBytes
    53  	scanint    int
    54  	scanint8   int8
    55  	scanint16  int16
    56  	scanint32  int32
    57  	scanuint8  uint8
    58  	scanuint16 uint16
    59  	scanbool   bool
    60  	scanf32    float32
    61  	scanf64    float64
    62  	scantime   time.Time
    63  	scanptr    *int64
    64  	scaniface  interface{}
    65  )
    66  
    67  func conversionTests() []conversionTest {
    68  	// Return a fresh instance to test so "go test -count 2" works correctly.
    69  	return []conversionTest{
    70  		// Exact conversions (destination pointer type matches source type)
    71  		{s: "foo", d: &scanstr, wantstr: "foo"},
    72  		{s: 123, d: &scanint, wantint: 123},
    73  		{s: someTime, d: &scantime, wanttime: someTime},
    74  
    75  		// To strings
    76  		{s: "string", d: &scanstr, wantstr: "string"},
    77  		{s: []byte("byteslice"), d: &scanstr, wantstr: "byteslice"},
    78  		{s: 123, d: &scanstr, wantstr: "123"},
    79  		{s: int8(123), d: &scanstr, wantstr: "123"},
    80  		{s: int64(123), d: &scanstr, wantstr: "123"},
    81  		{s: uint8(123), d: &scanstr, wantstr: "123"},
    82  		{s: uint16(123), d: &scanstr, wantstr: "123"},
    83  		{s: uint32(123), d: &scanstr, wantstr: "123"},
    84  		{s: uint64(123), d: &scanstr, wantstr: "123"},
    85  		{s: 1.5, d: &scanstr, wantstr: "1.5"},
    86  
    87  		// From time.Time:
    88  		{s: time.Unix(1, 0).UTC(), d: &scanstr, wantstr: "1970-01-01T00:00:01Z"},
    89  		{s: time.Unix(1453874597, 0).In(time.FixedZone("here", -3600*8)), d: &scanstr, wantstr: "2016-01-26T22:03:17-08:00"},
    90  		{s: time.Unix(1, 2).UTC(), d: &scanstr, wantstr: "1970-01-01T00:00:01.000000002Z"},
    91  		{s: time.Time{}, d: &scanstr, wantstr: "0001-01-01T00:00:00Z"},
    92  		{s: time.Unix(1, 2).UTC(), d: &scanbytes, wantbytes: []byte("1970-01-01T00:00:01.000000002Z")},
    93  		{s: time.Unix(1, 2).UTC(), d: &scaniface, wantiface: time.Unix(1, 2).UTC()},
    94  
    95  		// To []byte
    96  		{s: nil, d: &scanbytes, wantbytes: nil},
    97  		{s: "string", d: &scanbytes, wantbytes: []byte("string")},
    98  		{s: []byte("byteslice"), d: &scanbytes, wantbytes: []byte("byteslice")},
    99  		{s: 123, d: &scanbytes, wantbytes: []byte("123")},
   100  		{s: int8(123), d: &scanbytes, wantbytes: []byte("123")},
   101  		{s: int64(123), d: &scanbytes, wantbytes: []byte("123")},
   102  		{s: uint8(123), d: &scanbytes, wantbytes: []byte("123")},
   103  		{s: uint16(123), d: &scanbytes, wantbytes: []byte("123")},
   104  		{s: uint32(123), d: &scanbytes, wantbytes: []byte("123")},
   105  		{s: uint64(123), d: &scanbytes, wantbytes: []byte("123")},
   106  		{s: 1.5, d: &scanbytes, wantbytes: []byte("1.5")},
   107  
   108  		// To RawBytes
   109  		{s: nil, d: &scanraw, wantraw: nil},
   110  		{s: []byte("byteslice"), d: &scanraw, wantraw: RawBytes("byteslice")},
   111  		{s: "string", d: &scanraw, wantraw: RawBytes("string")},
   112  		{s: 123, d: &scanraw, wantraw: RawBytes("123")},
   113  		{s: int8(123), d: &scanraw, wantraw: RawBytes("123")},
   114  		{s: int64(123), d: &scanraw, wantraw: RawBytes("123")},
   115  		{s: uint8(123), d: &scanraw, wantraw: RawBytes("123")},
   116  		{s: uint16(123), d: &scanraw, wantraw: RawBytes("123")},
   117  		{s: uint32(123), d: &scanraw, wantraw: RawBytes("123")},
   118  		{s: uint64(123), d: &scanraw, wantraw: RawBytes("123")},
   119  		{s: 1.5, d: &scanraw, wantraw: RawBytes("1.5")},
   120  		// time.Time has been placed here to check that the RawBytes slice gets
   121  		// correctly reset when calling time.Time.AppendFormat.
   122  		{s: time.Unix(2, 5).UTC(), d: &scanraw, wantraw: RawBytes("1970-01-01T00:00:02.000000005Z")},
   123  
   124  		// Strings to integers
   125  		{s: "255", d: &scanuint8, wantuint: 255},
   126  		{s: "256", d: &scanuint8, wanterr: "converting driver.Value type string (\"256\") to a uint8: value out of range"},
   127  		{s: "256", d: &scanuint16, wantuint: 256},
   128  		{s: "-1", d: &scanint, wantint: -1},
   129  		{s: "foo", d: &scanint, wanterr: "converting driver.Value type string (\"foo\") to a int: invalid syntax"},
   130  
   131  		// int64 to smaller integers
   132  		{s: int64(5), d: &scanuint8, wantuint: 5},
   133  		{s: int64(256), d: &scanuint8, wanterr: "converting driver.Value type int64 (\"256\") to a uint8: value out of range"},
   134  		{s: int64(256), d: &scanuint16, wantuint: 256},
   135  		{s: int64(65536), d: &scanuint16, wanterr: "converting driver.Value type int64 (\"65536\") to a uint16: value out of range"},
   136  
   137  		// True bools
   138  		{s: true, d: &scanbool, wantbool: true},
   139  		{s: "True", d: &scanbool, wantbool: true},
   140  		{s: "TRUE", d: &scanbool, wantbool: true},
   141  		{s: "1", d: &scanbool, wantbool: true},
   142  		{s: 1, d: &scanbool, wantbool: true},
   143  		{s: int64(1), d: &scanbool, wantbool: true},
   144  		{s: uint16(1), d: &scanbool, wantbool: true},
   145  
   146  		// False bools
   147  		{s: false, d: &scanbool, wantbool: false},
   148  		{s: "false", d: &scanbool, wantbool: false},
   149  		{s: "FALSE", d: &scanbool, wantbool: false},
   150  		{s: "0", d: &scanbool, wantbool: false},
   151  		{s: 0, d: &scanbool, wantbool: false},
   152  		{s: int64(0), d: &scanbool, wantbool: false},
   153  		{s: uint16(0), d: &scanbool, wantbool: false},
   154  
   155  		// Not bools
   156  		{s: "yup", d: &scanbool, wanterr: `sql/driver: couldn't convert "yup" into type bool`},
   157  		{s: 2, d: &scanbool, wanterr: `sql/driver: couldn't convert 2 into type bool`},
   158  
   159  		// Floats
   160  		{s: float64(1.5), d: &scanf64, wantf64: float64(1.5)},
   161  		{s: int64(1), d: &scanf64, wantf64: float64(1)},
   162  		{s: float64(1.5), d: &scanf32, wantf32: float32(1.5)},
   163  		{s: "1.5", d: &scanf32, wantf32: float32(1.5)},
   164  		{s: "1.5", d: &scanf64, wantf64: float64(1.5)},
   165  
   166  		// Pointers
   167  		{s: interface{}(nil), d: &scanptr, wantnil: true},
   168  		{s: int64(42), d: &scanptr, wantptr: &answer},
   169  
   170  		// To interface{}
   171  		{s: float64(1.5), d: &scaniface, wantiface: float64(1.5)},
   172  		{s: int64(1), d: &scaniface, wantiface: int64(1)},
   173  		{s: "str", d: &scaniface, wantiface: "str"},
   174  		{s: []byte("byteslice"), d: &scaniface, wantiface: []byte("byteslice")},
   175  		{s: true, d: &scaniface, wantiface: true},
   176  		{s: nil, d: &scaniface},
   177  		{s: []byte(nil), d: &scaniface, wantiface: []byte(nil)},
   178  
   179  		// To a user-defined type
   180  		{s: 1.5, d: new(userDefined), wantusrdef: 1.5},
   181  		{s: int64(123), d: new(userDefined), wantusrdef: 123},
   182  		{s: "1.5", d: new(userDefined), wantusrdef: 1.5},
   183  		{s: []byte{1, 2, 3}, d: new(userDefinedSlice), wanterr: `unsupported Scan, storing driver.Value type []uint8 into type *sql.userDefinedSlice`},
   184  		{s: "str", d: new(userDefinedString), wantusrstr: "str"},
   185  
   186  		// Other errors
   187  		{s: complex(1, 2), d: &scanstr, wanterr: `unsupported Scan, storing driver.Value type complex128 into type *string`},
   188  	}
   189  }
   190  
   191  func intPtrValue(intptr interface{}) interface{} {
   192  	return reflect.Indirect(reflect.Indirect(reflect.ValueOf(intptr))).Int()
   193  }
   194  
   195  func intValue(intptr interface{}) int64 {
   196  	return reflect.Indirect(reflect.ValueOf(intptr)).Int()
   197  }
   198  
   199  func uintValue(intptr interface{}) uint64 {
   200  	return reflect.Indirect(reflect.ValueOf(intptr)).Uint()
   201  }
   202  
   203  func float64Value(ptr interface{}) float64 {
   204  	return *(ptr.(*float64))
   205  }
   206  
   207  func float32Value(ptr interface{}) float32 {
   208  	return *(ptr.(*float32))
   209  }
   210  
   211  func timeValue(ptr interface{}) time.Time {
   212  	return *(ptr.(*time.Time))
   213  }
   214  
   215  func TestConversions(t *testing.T) {
   216  	for n, ct := range conversionTests() {
   217  		err := convertAssign(ct.d, ct.s)
   218  		errstr := ""
   219  		if err != nil {
   220  			errstr = err.Error()
   221  		}
   222  		errf := func(format string, args ...interface{}) {
   223  			base := fmt.Sprintf("convertAssign #%d: for %v (%T) -> %T, ", n, ct.s, ct.s, ct.d)
   224  			t.Errorf(base+format, args...)
   225  		}
   226  		if errstr != ct.wanterr {
   227  			errf("got error %q, want error %q", errstr, ct.wanterr)
   228  		}
   229  		if ct.wantstr != "" && ct.wantstr != scanstr {
   230  			errf("want string %q, got %q", ct.wantstr, scanstr)
   231  		}
   232  		if ct.wantbytes != nil && string(ct.wantbytes) != string(scanbytes) {
   233  			errf("want byte %q, got %q", ct.wantbytes, scanbytes)
   234  		}
   235  		if ct.wantraw != nil && string(ct.wantraw) != string(scanraw) {
   236  			errf("want RawBytes %q, got %q", ct.wantraw, scanraw)
   237  		}
   238  		if ct.wantint != 0 && ct.wantint != intValue(ct.d) {
   239  			errf("want int %d, got %d", ct.wantint, intValue(ct.d))
   240  		}
   241  		if ct.wantuint != 0 && ct.wantuint != uintValue(ct.d) {
   242  			errf("want uint %d, got %d", ct.wantuint, uintValue(ct.d))
   243  		}
   244  		if ct.wantf32 != 0 && ct.wantf32 != float32Value(ct.d) {
   245  			errf("want float32 %v, got %v", ct.wantf32, float32Value(ct.d))
   246  		}
   247  		if ct.wantf64 != 0 && ct.wantf64 != float64Value(ct.d) {
   248  			errf("want float32 %v, got %v", ct.wantf64, float64Value(ct.d))
   249  		}
   250  		if bp, boolTest := ct.d.(*bool); boolTest && *bp != ct.wantbool && ct.wanterr == "" {
   251  			errf("want bool %v, got %v", ct.wantbool, *bp)
   252  		}
   253  		if !ct.wanttime.IsZero() && !ct.wanttime.Equal(timeValue(ct.d)) {
   254  			errf("want time %v, got %v", ct.wanttime, timeValue(ct.d))
   255  		}
   256  		if ct.wantnil && *ct.d.(**int64) != nil {
   257  			errf("want nil, got %v", intPtrValue(ct.d))
   258  		}
   259  		if ct.wantptr != nil {
   260  			if *ct.d.(**int64) == nil {
   261  				errf("want pointer to %v, got nil", *ct.wantptr)
   262  			} else if *ct.wantptr != intPtrValue(ct.d) {
   263  				errf("want pointer to %v, got %v", *ct.wantptr, intPtrValue(ct.d))
   264  			}
   265  		}
   266  		if ifptr, ok := ct.d.(*interface{}); ok {
   267  			if !reflect.DeepEqual(ct.wantiface, scaniface) {
   268  				errf("want interface %#v, got %#v", ct.wantiface, scaniface)
   269  				continue
   270  			}
   271  			if srcBytes, ok := ct.s.([]byte); ok {
   272  				dstBytes := (*ifptr).([]byte)
   273  				if len(srcBytes) > 0 && &dstBytes[0] == &srcBytes[0] {
   274  					errf("copy into interface{} didn't copy []byte data")
   275  				}
   276  			}
   277  		}
   278  		if ct.wantusrdef != 0 && ct.wantusrdef != *ct.d.(*userDefined) {
   279  			errf("want userDefined %f, got %f", ct.wantusrdef, *ct.d.(*userDefined))
   280  		}
   281  		if len(ct.wantusrstr) != 0 && ct.wantusrstr != *ct.d.(*userDefinedString) {
   282  			errf("want userDefined %q, got %q", ct.wantusrstr, *ct.d.(*userDefinedString))
   283  		}
   284  	}
   285  }
   286  
   287  func TestNullString(t *testing.T) {
   288  	var ns NullString
   289  	convertAssign(&ns, []byte("foo"))
   290  	if !ns.Valid {
   291  		t.Errorf("expecting not null")
   292  	}
   293  	if ns.String != "foo" {
   294  		t.Errorf("expecting foo; got %q", ns.String)
   295  	}
   296  	convertAssign(&ns, nil)
   297  	if ns.Valid {
   298  		t.Errorf("expecting null on nil")
   299  	}
   300  	if ns.String != "" {
   301  		t.Errorf("expecting blank on nil; got %q", ns.String)
   302  	}
   303  }
   304  
   305  type valueConverterTest struct {
   306  	c       driver.ValueConverter
   307  	in, out interface{}
   308  	err     string
   309  }
   310  
   311  var valueConverterTests = []valueConverterTest{
   312  	{driver.DefaultParameterConverter, NullString{"hi", true}, "hi", ""},
   313  	{driver.DefaultParameterConverter, NullString{"", false}, nil, ""},
   314  }
   315  
   316  func TestValueConverters(t *testing.T) {
   317  	for i, tt := range valueConverterTests {
   318  		out, err := tt.c.ConvertValue(tt.in)
   319  		goterr := ""
   320  		if err != nil {
   321  			goterr = err.Error()
   322  		}
   323  		if goterr != tt.err {
   324  			t.Errorf("test %d: %T(%T(%v)) error = %q; want error = %q",
   325  				i, tt.c, tt.in, tt.in, goterr, tt.err)
   326  		}
   327  		if tt.err != "" {
   328  			continue
   329  		}
   330  		if !reflect.DeepEqual(out, tt.out) {
   331  			t.Errorf("test %d: %T(%T(%v)) = %v (%T); want %v (%T)",
   332  				i, tt.c, tt.in, tt.in, out, out, tt.out, tt.out)
   333  		}
   334  	}
   335  }
   336  
   337  // Tests that assigning to RawBytes doesn't allocate (and also works).
   338  func TestRawBytesAllocs(t *testing.T) {
   339  	var tests = []struct {
   340  		name string
   341  		in   interface{}
   342  		want string
   343  	}{
   344  		{"uint64", uint64(12345678), "12345678"},
   345  		{"uint32", uint32(1234), "1234"},
   346  		{"uint16", uint16(12), "12"},
   347  		{"uint8", uint8(1), "1"},
   348  		{"uint", uint(123), "123"},
   349  		{"int", int(123), "123"},
   350  		{"int8", int8(1), "1"},
   351  		{"int16", int16(12), "12"},
   352  		{"int32", int32(1234), "1234"},
   353  		{"int64", int64(12345678), "12345678"},
   354  		{"float32", float32(1.5), "1.5"},
   355  		{"float64", float64(64), "64"},
   356  		{"bool", false, "false"},
   357  		{"time", time.Unix(2, 5).UTC(), "1970-01-01T00:00:02.000000005Z"},
   358  	}
   359  
   360  	buf := make(RawBytes, 10)
   361  	test := func(name string, in interface{}, want string) {
   362  		if err := convertAssign(&buf, in); err != nil {
   363  			t.Fatalf("%s: convertAssign = %v", name, err)
   364  		}
   365  		match := len(buf) == len(want)
   366  		if match {
   367  			for i, b := range buf {
   368  				if want[i] != b {
   369  					match = false
   370  					break
   371  				}
   372  			}
   373  		}
   374  		if !match {
   375  			t.Fatalf("%s: got %q (len %d); want %q (len %d)", name, buf, len(buf), want, len(want))
   376  		}
   377  	}
   378  
   379  	n := testing.AllocsPerRun(100, func() {
   380  		for _, tt := range tests {
   381  			test(tt.name, tt.in, tt.want)
   382  		}
   383  	})
   384  
   385  	// The numbers below are only valid for 64-bit interface word sizes,
   386  	// and gc. With 32-bit words there are more convT2E allocs, and
   387  	// with gccgo, only pointers currently go in interface data.
   388  	// So only care on amd64 gc for now.
   389  	measureAllocs := runtime.GOARCH == "amd64" && runtime.Compiler == "gc"
   390  
   391  	if n > 0.5 && measureAllocs {
   392  		t.Fatalf("allocs = %v; want 0", n)
   393  	}
   394  
   395  	// This one involves a convT2E allocation, string -> interface{}
   396  	n = testing.AllocsPerRun(100, func() {
   397  		test("string", "foo", "foo")
   398  	})
   399  	if n > 1.5 && measureAllocs {
   400  		t.Fatalf("allocs = %v; want max 1", n)
   401  	}
   402  }
   403  
   404  // https://golang.org/issues/13905
   405  func TestUserDefinedBytes(t *testing.T) {
   406  	type userDefinedBytes []byte
   407  	var u userDefinedBytes
   408  	v := []byte("foo")
   409  
   410  	convertAssign(&u, v)
   411  	if &u[0] == &v[0] {
   412  		t.Fatal("userDefinedBytes got potentially dirty driver memory")
   413  	}
   414  }
   415  
   416  type Valuer_V string
   417  
   418  func (v Valuer_V) Value() (driver.Value, error) {
   419  	return strings.ToUpper(string(v)), nil
   420  }
   421  
   422  type Valuer_P string
   423  
   424  func (p *Valuer_P) Value() (driver.Value, error) {
   425  	if p == nil {
   426  		return "nil-to-str", nil
   427  	}
   428  	return strings.ToUpper(string(*p)), nil
   429  }
   430  
   431  func TestDriverArgs(t *testing.T) {
   432  	var nilValuerVPtr *Valuer_V
   433  	var nilValuerPPtr *Valuer_P
   434  	var nilStrPtr *string
   435  	tests := []struct {
   436  		args []interface{}
   437  		want []driver.NamedValue
   438  	}{
   439  		0: {
   440  			args: []interface{}{Valuer_V("foo")},
   441  			want: []driver.NamedValue{
   442  				driver.NamedValue{
   443  					Ordinal: 1,
   444  					Value:   "FOO",
   445  				},
   446  			},
   447  		},
   448  		1: {
   449  			args: []interface{}{nilValuerVPtr},
   450  			want: []driver.NamedValue{
   451  				driver.NamedValue{
   452  					Ordinal: 1,
   453  					Value:   nil,
   454  				},
   455  			},
   456  		},
   457  		2: {
   458  			args: []interface{}{nilValuerPPtr},
   459  			want: []driver.NamedValue{
   460  				driver.NamedValue{
   461  					Ordinal: 1,
   462  					Value:   "nil-to-str",
   463  				},
   464  			},
   465  		},
   466  		3: {
   467  			args: []interface{}{"plain-str"},
   468  			want: []driver.NamedValue{
   469  				driver.NamedValue{
   470  					Ordinal: 1,
   471  					Value:   "plain-str",
   472  				},
   473  			},
   474  		},
   475  		4: {
   476  			args: []interface{}{nilStrPtr},
   477  			want: []driver.NamedValue{
   478  				driver.NamedValue{
   479  					Ordinal: 1,
   480  					Value:   nil,
   481  				},
   482  			},
   483  		},
   484  	}
   485  	for i, tt := range tests {
   486  		ds := &driverStmt{Locker: &sync.Mutex{}, si: stubDriverStmt{nil}}
   487  		got, err := driverArgsConnLocked(nil, ds, tt.args)
   488  		if err != nil {
   489  			t.Errorf("test[%d]: %v", i, err)
   490  			continue
   491  		}
   492  		if !reflect.DeepEqual(got, tt.want) {
   493  			t.Errorf("test[%d]: got %v, want %v", i, got, tt.want)
   494  		}
   495  	}
   496  }
   497  

View as plain text