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