521 lines
13 KiB
Go
521 lines
13 KiB
Go
// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
|
|
//
|
|
// Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
// You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
package mysql
|
|
|
|
import (
|
|
"bytes"
|
|
"database/sql"
|
|
"database/sql/driver"
|
|
"encoding/binary"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestLengthEncodedInteger(t *testing.T) {
|
|
var integerTests = []struct {
|
|
num uint64
|
|
encoded []byte
|
|
}{
|
|
{0x0000000000000000, []byte{0x00}},
|
|
{0x0000000000000012, []byte{0x12}},
|
|
{0x00000000000000fa, []byte{0xfa}},
|
|
{0x0000000000000100, []byte{0xfc, 0x00, 0x01}},
|
|
{0x0000000000001234, []byte{0xfc, 0x34, 0x12}},
|
|
{0x000000000000ffff, []byte{0xfc, 0xff, 0xff}},
|
|
{0x0000000000010000, []byte{0xfd, 0x00, 0x00, 0x01}},
|
|
{0x0000000000123456, []byte{0xfd, 0x56, 0x34, 0x12}},
|
|
{0x0000000000ffffff, []byte{0xfd, 0xff, 0xff, 0xff}},
|
|
{0x0000000001000000, []byte{0xfe, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00}},
|
|
{0x123456789abcdef0, []byte{0xfe, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12}},
|
|
{0xffffffffffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
|
|
}
|
|
|
|
for _, tst := range integerTests {
|
|
num, isNull, numLen := readLengthEncodedInteger(tst.encoded)
|
|
if isNull {
|
|
t.Errorf("%x: expected %d, got NULL", tst.encoded, tst.num)
|
|
}
|
|
if num != tst.num {
|
|
t.Errorf("%x: expected %d, got %d", tst.encoded, tst.num, num)
|
|
}
|
|
if numLen != len(tst.encoded) {
|
|
t.Errorf("%x: expected size %d, got %d", tst.encoded, len(tst.encoded), numLen)
|
|
}
|
|
encoded := appendLengthEncodedInteger(nil, num)
|
|
if !bytes.Equal(encoded, tst.encoded) {
|
|
t.Errorf("%v: expected %x, got %x", num, tst.encoded, encoded)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFormatBinaryDateTime(t *testing.T) {
|
|
rawDate := [11]byte{}
|
|
binary.LittleEndian.PutUint16(rawDate[:2], 1978) // years
|
|
rawDate[2] = 12 // months
|
|
rawDate[3] = 30 // days
|
|
rawDate[4] = 15 // hours
|
|
rawDate[5] = 46 // minutes
|
|
rawDate[6] = 23 // seconds
|
|
binary.LittleEndian.PutUint32(rawDate[7:], 987654) // microseconds
|
|
expect := func(expected string, inlen, outlen uint8) {
|
|
actual, _ := formatBinaryDateTime(rawDate[:inlen], outlen)
|
|
bytes, ok := actual.([]byte)
|
|
if !ok {
|
|
t.Errorf("formatBinaryDateTime must return []byte, was %T", actual)
|
|
}
|
|
if string(bytes) != expected {
|
|
t.Errorf(
|
|
"expected %q, got %q for length in %d, out %d",
|
|
expected, actual, inlen, outlen,
|
|
)
|
|
}
|
|
}
|
|
expect("0000-00-00", 0, 10)
|
|
expect("0000-00-00 00:00:00", 0, 19)
|
|
expect("1978-12-30", 4, 10)
|
|
expect("1978-12-30 15:46:23", 7, 19)
|
|
expect("1978-12-30 15:46:23.987654", 11, 26)
|
|
}
|
|
|
|
func TestFormatBinaryTime(t *testing.T) {
|
|
expect := func(expected string, src []byte, outlen uint8) {
|
|
actual, _ := formatBinaryTime(src, outlen)
|
|
bytes, ok := actual.([]byte)
|
|
if !ok {
|
|
t.Errorf("formatBinaryDateTime must return []byte, was %T", actual)
|
|
}
|
|
if string(bytes) != expected {
|
|
t.Errorf(
|
|
"expected %q, got %q for src=%q and outlen=%d",
|
|
expected, actual, src, outlen)
|
|
}
|
|
}
|
|
|
|
// binary format:
|
|
// sign (0: positive, 1: negative), days(4), hours, minutes, seconds, micro(4)
|
|
|
|
// Zeros
|
|
expect("00:00:00", []byte{}, 8)
|
|
expect("00:00:00.0", []byte{}, 10)
|
|
expect("00:00:00.000000", []byte{}, 15)
|
|
|
|
// Without micro(4)
|
|
expect("12:34:56", []byte{0, 0, 0, 0, 0, 12, 34, 56}, 8)
|
|
expect("-12:34:56", []byte{1, 0, 0, 0, 0, 12, 34, 56}, 8)
|
|
expect("12:34:56.00", []byte{0, 0, 0, 0, 0, 12, 34, 56}, 11)
|
|
expect("24:34:56", []byte{0, 1, 0, 0, 0, 0, 34, 56}, 8)
|
|
expect("-99:34:56", []byte{1, 4, 0, 0, 0, 3, 34, 56}, 8)
|
|
expect("103079215103:34:56", []byte{0, 255, 255, 255, 255, 23, 34, 56}, 8)
|
|
|
|
// With micro(4)
|
|
expect("12:34:56.00", []byte{0, 0, 0, 0, 0, 12, 34, 56, 99, 0, 0, 0}, 11)
|
|
expect("12:34:56.000099", []byte{0, 0, 0, 0, 0, 12, 34, 56, 99, 0, 0, 0}, 15)
|
|
}
|
|
|
|
func TestEscapeBackslash(t *testing.T) {
|
|
expect := func(expected, value string) {
|
|
actual := string(escapeBytesBackslash([]byte{}, []byte(value)))
|
|
if actual != expected {
|
|
t.Errorf(
|
|
"expected %s, got %s",
|
|
expected, actual,
|
|
)
|
|
}
|
|
|
|
actual = string(escapeStringBackslash([]byte{}, value))
|
|
if actual != expected {
|
|
t.Errorf(
|
|
"expected %s, got %s",
|
|
expected, actual,
|
|
)
|
|
}
|
|
}
|
|
|
|
expect("foo\\0bar", "foo\x00bar")
|
|
expect("foo\\nbar", "foo\nbar")
|
|
expect("foo\\rbar", "foo\rbar")
|
|
expect("foo\\Zbar", "foo\x1abar")
|
|
expect("foo\\\"bar", "foo\"bar")
|
|
expect("foo\\\\bar", "foo\\bar")
|
|
expect("foo\\'bar", "foo'bar")
|
|
}
|
|
|
|
func TestEscapeQuotes(t *testing.T) {
|
|
expect := func(expected, value string) {
|
|
actual := string(escapeBytesQuotes([]byte{}, []byte(value)))
|
|
if actual != expected {
|
|
t.Errorf(
|
|
"expected %s, got %s",
|
|
expected, actual,
|
|
)
|
|
}
|
|
|
|
actual = string(escapeStringQuotes([]byte{}, value))
|
|
if actual != expected {
|
|
t.Errorf(
|
|
"expected %s, got %s",
|
|
expected, actual,
|
|
)
|
|
}
|
|
}
|
|
|
|
expect("foo\x00bar", "foo\x00bar") // not affected
|
|
expect("foo\nbar", "foo\nbar") // not affected
|
|
expect("foo\rbar", "foo\rbar") // not affected
|
|
expect("foo\x1abar", "foo\x1abar") // not affected
|
|
expect("foo''bar", "foo'bar") // affected
|
|
expect("foo\"bar", "foo\"bar") // not affected
|
|
}
|
|
|
|
func TestAtomicError(t *testing.T) {
|
|
var ae atomicError
|
|
if ae.Value() != nil {
|
|
t.Fatal("Expected value to be nil")
|
|
}
|
|
|
|
ae.Set(ErrMalformPkt)
|
|
if v := ae.Value(); v != ErrMalformPkt {
|
|
if v == nil {
|
|
t.Fatal("Value is still nil")
|
|
}
|
|
t.Fatal("Error did not match")
|
|
}
|
|
ae.Set(ErrPktSync)
|
|
if ae.Value() == ErrMalformPkt {
|
|
t.Fatal("Error still matches old error")
|
|
}
|
|
if v := ae.Value(); v != ErrPktSync {
|
|
t.Fatal("Error did not match")
|
|
}
|
|
}
|
|
|
|
func TestIsolationLevelMapping(t *testing.T) {
|
|
data := []struct {
|
|
level driver.IsolationLevel
|
|
expected string
|
|
}{
|
|
{
|
|
level: driver.IsolationLevel(sql.LevelReadCommitted),
|
|
expected: "READ COMMITTED",
|
|
},
|
|
{
|
|
level: driver.IsolationLevel(sql.LevelRepeatableRead),
|
|
expected: "REPEATABLE READ",
|
|
},
|
|
{
|
|
level: driver.IsolationLevel(sql.LevelReadUncommitted),
|
|
expected: "READ UNCOMMITTED",
|
|
},
|
|
{
|
|
level: driver.IsolationLevel(sql.LevelSerializable),
|
|
expected: "SERIALIZABLE",
|
|
},
|
|
}
|
|
|
|
for i, td := range data {
|
|
if actual, err := mapIsolationLevel(td.level); actual != td.expected || err != nil {
|
|
t.Fatal(i, td.expected, actual, err)
|
|
}
|
|
}
|
|
|
|
// check unsupported mapping
|
|
expectedErr := "mysql: unsupported isolation level: 7"
|
|
actual, err := mapIsolationLevel(driver.IsolationLevel(sql.LevelLinearizable))
|
|
if actual != "" || err == nil {
|
|
t.Fatal("Expected error on unsupported isolation level")
|
|
}
|
|
if err.Error() != expectedErr {
|
|
t.Fatalf("Expected error to be %q, got %q", expectedErr, err)
|
|
}
|
|
}
|
|
|
|
func TestAppendDateTime(t *testing.T) {
|
|
tests := []struct {
|
|
t time.Time
|
|
str string
|
|
timeTruncate time.Duration
|
|
expectedErr bool
|
|
}{
|
|
{
|
|
t: time.Date(1234, 5, 6, 0, 0, 0, 0, time.UTC),
|
|
str: "1234-05-06",
|
|
},
|
|
{
|
|
t: time.Date(4567, 12, 31, 12, 0, 0, 0, time.UTC),
|
|
str: "4567-12-31 12:00:00",
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 12, 34, 0, 0, time.UTC),
|
|
str: "2020-05-30 12:34:00",
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 12, 34, 56, 0, time.UTC),
|
|
str: "2020-05-30 12:34:56",
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 22, 33, 44, 123000000, time.UTC),
|
|
str: "2020-05-30 22:33:44.123",
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 22, 33, 44, 123456000, time.UTC),
|
|
str: "2020-05-30 22:33:44.123456",
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 22, 33, 44, 123456789, time.UTC),
|
|
str: "2020-05-30 22:33:44.123456789",
|
|
},
|
|
{
|
|
t: time.Date(9999, 12, 31, 23, 59, 59, 999999999, time.UTC),
|
|
str: "9999-12-31 23:59:59.999999999",
|
|
},
|
|
{
|
|
t: time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC),
|
|
str: "0001-01-01",
|
|
},
|
|
// Truncated time
|
|
{
|
|
t: time.Date(1234, 5, 6, 0, 0, 0, 0, time.UTC),
|
|
str: "1234-05-06",
|
|
timeTruncate: time.Second,
|
|
},
|
|
{
|
|
t: time.Date(4567, 12, 31, 12, 0, 0, 0, time.UTC),
|
|
str: "4567-12-31 12:00:00",
|
|
timeTruncate: time.Minute,
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 12, 34, 0, 0, time.UTC),
|
|
str: "2020-05-30 12:34:00",
|
|
timeTruncate: 0,
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 12, 34, 56, 0, time.UTC),
|
|
str: "2020-05-30 12:34:56",
|
|
timeTruncate: time.Second,
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 22, 33, 44, 123000000, time.UTC),
|
|
str: "2020-05-30 22:33:44",
|
|
timeTruncate: time.Second,
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 22, 33, 44, 123456000, time.UTC),
|
|
str: "2020-05-30 22:33:44.123",
|
|
timeTruncate: time.Millisecond,
|
|
},
|
|
{
|
|
t: time.Date(2020, 5, 30, 22, 33, 44, 123456789, time.UTC),
|
|
str: "2020-05-30 22:33:44",
|
|
timeTruncate: time.Second,
|
|
},
|
|
{
|
|
t: time.Date(9999, 12, 31, 23, 59, 59, 999999999, time.UTC),
|
|
str: "9999-12-31 23:59:59.999999999",
|
|
timeTruncate: 0,
|
|
},
|
|
{
|
|
t: time.Date(1, 1, 1, 1, 1, 1, 1, time.UTC),
|
|
str: "0001-01-01",
|
|
timeTruncate: 365 * 24 * time.Hour,
|
|
},
|
|
// year out of range
|
|
{
|
|
t: time.Date(0, 1, 1, 0, 0, 0, 0, time.UTC),
|
|
expectedErr: true,
|
|
},
|
|
{
|
|
t: time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC),
|
|
expectedErr: true,
|
|
},
|
|
}
|
|
for _, v := range tests {
|
|
buf := make([]byte, 0, 32)
|
|
buf, err := appendDateTime(buf, v.t, v.timeTruncate)
|
|
if err != nil {
|
|
if !v.expectedErr {
|
|
t.Errorf("appendDateTime(%v) returned an errror: %v", v.t, err)
|
|
}
|
|
continue
|
|
}
|
|
if str := string(buf); str != v.str {
|
|
t.Errorf("appendDateTime(%v), have: %s, want: %s", v.t, str, v.str)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseDateTime(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
str string
|
|
}{
|
|
{
|
|
name: "parse date",
|
|
str: "2020-05-13",
|
|
},
|
|
{
|
|
name: "parse null date",
|
|
str: sDate0,
|
|
},
|
|
{
|
|
name: "parse datetime",
|
|
str: "2020-05-13 21:30:45",
|
|
},
|
|
{
|
|
name: "parse null datetime",
|
|
str: sDateTime0,
|
|
},
|
|
{
|
|
name: "parse datetime nanosec 1-digit",
|
|
str: "2020-05-25 23:22:01.1",
|
|
},
|
|
{
|
|
name: "parse datetime nanosec 2-digits",
|
|
str: "2020-05-25 23:22:01.15",
|
|
},
|
|
{
|
|
name: "parse datetime nanosec 3-digits",
|
|
str: "2020-05-25 23:22:01.159",
|
|
},
|
|
{
|
|
name: "parse datetime nanosec 4-digits",
|
|
str: "2020-05-25 23:22:01.1594",
|
|
},
|
|
{
|
|
name: "parse datetime nanosec 5-digits",
|
|
str: "2020-05-25 23:22:01.15949",
|
|
},
|
|
{
|
|
name: "parse datetime nanosec 6-digits",
|
|
str: "2020-05-25 23:22:01.159491",
|
|
},
|
|
}
|
|
|
|
for _, loc := range []*time.Location{
|
|
time.UTC,
|
|
time.FixedZone("test", 8*60*60),
|
|
} {
|
|
for _, cc := range cases {
|
|
t.Run(cc.name+"-"+loc.String(), func(t *testing.T) {
|
|
var want time.Time
|
|
if cc.str != sDate0 && cc.str != sDateTime0 {
|
|
var err error
|
|
want, err = time.ParseInLocation(timeFormat[:len(cc.str)], cc.str, loc)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
got, err := parseDateTime([]byte(cc.str), loc)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !want.Equal(got) {
|
|
t.Fatalf("want: %v, but got %v", want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestInvalidDateTime(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
str string
|
|
want time.Time
|
|
}{
|
|
{
|
|
name: "parse datetime without day",
|
|
str: "0000-00-00 21:30:45",
|
|
want: time.Date(0, 0, 0, 21, 30, 45, 0, time.UTC),
|
|
},
|
|
}
|
|
|
|
for _, cc := range cases {
|
|
t.Run(cc.name, func(t *testing.T) {
|
|
got, err := parseDateTime([]byte(cc.str), time.UTC)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if !cc.want.Equal(got) {
|
|
t.Fatalf("want: %v, but got %v", cc.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseDateTimeFail(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
str string
|
|
wantErr string
|
|
}{
|
|
{
|
|
name: "parse invalid time",
|
|
str: "hello",
|
|
wantErr: "invalid time bytes: hello",
|
|
},
|
|
{
|
|
name: "parse year",
|
|
str: "000!-00-00 00:00:00.000000",
|
|
wantErr: "not [0-9]",
|
|
},
|
|
{
|
|
name: "parse month",
|
|
str: "0000-!0-00 00:00:00.000000",
|
|
wantErr: "not [0-9]",
|
|
},
|
|
{
|
|
name: `parse "-" after parsed year`,
|
|
str: "0000:00-00 00:00:00.000000",
|
|
wantErr: "bad value for field: `:`",
|
|
},
|
|
{
|
|
name: `parse "-" after parsed month`,
|
|
str: "0000-00:00 00:00:00.000000",
|
|
wantErr: "bad value for field: `:`",
|
|
},
|
|
{
|
|
name: `parse " " after parsed date`,
|
|
str: "0000-00-00+00:00:00.000000",
|
|
wantErr: "bad value for field: `+`",
|
|
},
|
|
{
|
|
name: `parse ":" after parsed date`,
|
|
str: "0000-00-00 00-00:00.000000",
|
|
wantErr: "bad value for field: `-`",
|
|
},
|
|
{
|
|
name: `parse ":" after parsed hour`,
|
|
str: "0000-00-00 00:00-00.000000",
|
|
wantErr: "bad value for field: `-`",
|
|
},
|
|
{
|
|
name: `parse "." after parsed sec`,
|
|
str: "0000-00-00 00:00:00?000000",
|
|
wantErr: "bad value for field: `?`",
|
|
},
|
|
}
|
|
|
|
for _, cc := range cases {
|
|
t.Run(cc.name, func(t *testing.T) {
|
|
got, err := parseDateTime([]byte(cc.str), time.UTC)
|
|
if err == nil {
|
|
t.Fatal("want error")
|
|
}
|
|
if cc.wantErr != err.Error() {
|
|
t.Fatalf("want `%s`, but got `%s`", cc.wantErr, err)
|
|
}
|
|
if !got.IsZero() {
|
|
t.Fatal("want zero time")
|
|
}
|
|
})
|
|
}
|
|
}
|