mirror of
https://github.com/documize/community.git
synced 2025-07-20 13:49:42 +02:00
WIP vendored dep upgrades
This commit is contained in:
Harvey Kandola
parent
5f59e95495
commit
6409ad0d63
190 changed files with 64265 additions and 109666 deletions
276
vendor/github.com/go-sql-driver/mysql/driver_go18_test.go
generated
vendored
276
vendor/github.com/go-sql-driver/mysql/driver_go18_test.go
generated
vendored
|
|
@ -15,6 +15,7 @@ import (
|
|||
"database/sql"
|
||||
"database/sql/driver"
|
||||
"fmt"
|
||||
"math"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -35,6 +36,22 @@ var (
|
|||
_ driver.StmtQueryContext = &mysqlStmt{}
|
||||
)
|
||||
|
||||
// Ensure that all the driver interfaces are implemented
|
||||
var (
|
||||
// _ driver.RowsColumnTypeLength = &binaryRows{}
|
||||
// _ driver.RowsColumnTypeLength = &textRows{}
|
||||
_ driver.RowsColumnTypeDatabaseTypeName = &binaryRows{}
|
||||
_ driver.RowsColumnTypeDatabaseTypeName = &textRows{}
|
||||
_ driver.RowsColumnTypeNullable = &binaryRows{}
|
||||
_ driver.RowsColumnTypeNullable = &textRows{}
|
||||
_ driver.RowsColumnTypePrecisionScale = &binaryRows{}
|
||||
_ driver.RowsColumnTypePrecisionScale = &textRows{}
|
||||
_ driver.RowsColumnTypeScanType = &binaryRows{}
|
||||
_ driver.RowsColumnTypeScanType = &textRows{}
|
||||
_ driver.RowsNextResultSet = &binaryRows{}
|
||||
_ driver.RowsNextResultSet = &textRows{}
|
||||
)
|
||||
|
||||
func TestMultiResultSet(t *testing.T) {
|
||||
type result struct {
|
||||
values [][]int
|
||||
|
|
@ -520,3 +537,262 @@ func TestContextBeginIsolationLevel(t *testing.T) {
|
|||
tx2.Commit()
|
||||
})
|
||||
}
|
||||
|
||||
func TestContextBeginReadOnly(t *testing.T) {
|
||||
runTests(t, dsn, func(dbt *DBTest) {
|
||||
dbt.mustExec("CREATE TABLE test (v INTEGER)")
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
defer cancel()
|
||||
|
||||
tx, err := dbt.db.BeginTx(ctx, &sql.TxOptions{
|
||||
ReadOnly: true,
|
||||
})
|
||||
if _, ok := err.(*MySQLError); ok {
|
||||
dbt.Skip("It seems that your MySQL does not support READ ONLY transactions")
|
||||
return
|
||||
} else if err != nil {
|
||||
dbt.Fatal(err)
|
||||
}
|
||||
|
||||
// INSERT queries fail in a READ ONLY transaction.
|
||||
_, err = tx.ExecContext(ctx, "INSERT INTO test VALUES (1)")
|
||||
if _, ok := err.(*MySQLError); !ok {
|
||||
dbt.Errorf("expected MySQLError, got %v", err)
|
||||
}
|
||||
|
||||
// SELECT queries can be executed.
|
||||
var v int
|
||||
row := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM test")
|
||||
if err := row.Scan(&v); err != nil {
|
||||
dbt.Fatal(err)
|
||||
}
|
||||
if v != 0 {
|
||||
dbt.Errorf("expected val to be 0, got %d", v)
|
||||
}
|
||||
|
||||
if err := tx.Commit(); err != nil {
|
||||
dbt.Fatal(err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestRowsColumnTypes(t *testing.T) {
|
||||
niNULL := sql.NullInt64{Int64: 0, Valid: false}
|
||||
ni0 := sql.NullInt64{Int64: 0, Valid: true}
|
||||
ni1 := sql.NullInt64{Int64: 1, Valid: true}
|
||||
ni42 := sql.NullInt64{Int64: 42, Valid: true}
|
||||
nfNULL := sql.NullFloat64{Float64: 0.0, Valid: false}
|
||||
nf0 := sql.NullFloat64{Float64: 0.0, Valid: true}
|
||||
nf1337 := sql.NullFloat64{Float64: 13.37, Valid: true}
|
||||
nt0 := NullTime{Time: time.Date(2006, 01, 02, 15, 04, 05, 0, time.UTC), Valid: true}
|
||||
nt1 := NullTime{Time: time.Date(2006, 01, 02, 15, 04, 05, 100000000, time.UTC), Valid: true}
|
||||
nt2 := NullTime{Time: time.Date(2006, 01, 02, 15, 04, 05, 110000000, time.UTC), Valid: true}
|
||||
nt6 := NullTime{Time: time.Date(2006, 01, 02, 15, 04, 05, 111111000, time.UTC), Valid: true}
|
||||
nd1 := NullTime{Time: time.Date(2006, 01, 02, 0, 0, 0, 0, time.UTC), Valid: true}
|
||||
nd2 := NullTime{Time: time.Date(2006, 03, 04, 0, 0, 0, 0, time.UTC), Valid: true}
|
||||
ndNULL := NullTime{Time: time.Time{}, Valid: false}
|
||||
rbNULL := sql.RawBytes(nil)
|
||||
rb0 := sql.RawBytes("0")
|
||||
rb42 := sql.RawBytes("42")
|
||||
rbTest := sql.RawBytes("Test")
|
||||
rb0pad4 := sql.RawBytes("0\x00\x00\x00") // BINARY right-pads values with 0x00
|
||||
rbx0 := sql.RawBytes("\x00")
|
||||
rbx42 := sql.RawBytes("\x42")
|
||||
|
||||
var columns = []struct {
|
||||
name string
|
||||
fieldType string // type used when creating table schema
|
||||
databaseTypeName string // actual type used by MySQL
|
||||
scanType reflect.Type
|
||||
nullable bool
|
||||
precision int64 // 0 if not ok
|
||||
scale int64
|
||||
valuesIn [3]string
|
||||
valuesOut [3]interface{}
|
||||
}{
|
||||
{"bit8null", "BIT(8)", "BIT", scanTypeRawBytes, true, 0, 0, [3]string{"0x0", "NULL", "0x42"}, [3]interface{}{rbx0, rbNULL, rbx42}},
|
||||
{"boolnull", "BOOL", "TINYINT", scanTypeNullInt, true, 0, 0, [3]string{"NULL", "true", "0"}, [3]interface{}{niNULL, ni1, ni0}},
|
||||
{"bool", "BOOL NOT NULL", "TINYINT", scanTypeInt8, false, 0, 0, [3]string{"1", "0", "FALSE"}, [3]interface{}{int8(1), int8(0), int8(0)}},
|
||||
{"intnull", "INTEGER", "INT", scanTypeNullInt, true, 0, 0, [3]string{"0", "NULL", "42"}, [3]interface{}{ni0, niNULL, ni42}},
|
||||
{"smallint", "SMALLINT NOT NULL", "SMALLINT", scanTypeInt16, false, 0, 0, [3]string{"0", "-32768", "32767"}, [3]interface{}{int16(0), int16(-32768), int16(32767)}},
|
||||
{"smallintnull", "SMALLINT", "SMALLINT", scanTypeNullInt, true, 0, 0, [3]string{"0", "NULL", "42"}, [3]interface{}{ni0, niNULL, ni42}},
|
||||
{"int3null", "INT(3)", "INT", scanTypeNullInt, true, 0, 0, [3]string{"0", "NULL", "42"}, [3]interface{}{ni0, niNULL, ni42}},
|
||||
{"int7", "INT(7) NOT NULL", "INT", scanTypeInt32, false, 0, 0, [3]string{"0", "-1337", "42"}, [3]interface{}{int32(0), int32(-1337), int32(42)}},
|
||||
{"mediumintnull", "MEDIUMINT", "MEDIUMINT", scanTypeNullInt, true, 0, 0, [3]string{"0", "42", "NULL"}, [3]interface{}{ni0, ni42, niNULL}},
|
||||
{"bigint", "BIGINT NOT NULL", "BIGINT", scanTypeInt64, false, 0, 0, [3]string{"0", "65535", "-42"}, [3]interface{}{int64(0), int64(65535), int64(-42)}},
|
||||
{"bigintnull", "BIGINT", "BIGINT", scanTypeNullInt, true, 0, 0, [3]string{"NULL", "1", "42"}, [3]interface{}{niNULL, ni1, ni42}},
|
||||
{"tinyuint", "TINYINT UNSIGNED NOT NULL", "TINYINT", scanTypeUint8, false, 0, 0, [3]string{"0", "255", "42"}, [3]interface{}{uint8(0), uint8(255), uint8(42)}},
|
||||
{"smalluint", "SMALLINT UNSIGNED NOT NULL", "SMALLINT", scanTypeUint16, false, 0, 0, [3]string{"0", "65535", "42"}, [3]interface{}{uint16(0), uint16(65535), uint16(42)}},
|
||||
{"biguint", "BIGINT UNSIGNED NOT NULL", "BIGINT", scanTypeUint64, false, 0, 0, [3]string{"0", "65535", "42"}, [3]interface{}{uint64(0), uint64(65535), uint64(42)}},
|
||||
{"uint13", "INT(13) UNSIGNED NOT NULL", "INT", scanTypeUint32, false, 0, 0, [3]string{"0", "1337", "42"}, [3]interface{}{uint32(0), uint32(1337), uint32(42)}},
|
||||
{"float", "FLOAT NOT NULL", "FLOAT", scanTypeFloat32, false, math.MaxInt64, math.MaxInt64, [3]string{"0", "42", "13.37"}, [3]interface{}{float32(0), float32(42), float32(13.37)}},
|
||||
{"floatnull", "FLOAT", "FLOAT", scanTypeNullFloat, true, math.MaxInt64, math.MaxInt64, [3]string{"0", "NULL", "13.37"}, [3]interface{}{nf0, nfNULL, nf1337}},
|
||||
{"float74null", "FLOAT(7,4)", "FLOAT", scanTypeNullFloat, true, math.MaxInt64, 4, [3]string{"0", "NULL", "13.37"}, [3]interface{}{nf0, nfNULL, nf1337}},
|
||||
{"double", "DOUBLE NOT NULL", "DOUBLE", scanTypeFloat64, false, math.MaxInt64, math.MaxInt64, [3]string{"0", "42", "13.37"}, [3]interface{}{float64(0), float64(42), float64(13.37)}},
|
||||
{"doublenull", "DOUBLE", "DOUBLE", scanTypeNullFloat, true, math.MaxInt64, math.MaxInt64, [3]string{"0", "NULL", "13.37"}, [3]interface{}{nf0, nfNULL, nf1337}},
|
||||
{"decimal1", "DECIMAL(10,6) NOT NULL", "DECIMAL", scanTypeRawBytes, false, 10, 6, [3]string{"0", "13.37", "1234.123456"}, [3]interface{}{sql.RawBytes("0.000000"), sql.RawBytes("13.370000"), sql.RawBytes("1234.123456")}},
|
||||
{"decimal1null", "DECIMAL(10,6)", "DECIMAL", scanTypeRawBytes, true, 10, 6, [3]string{"0", "NULL", "1234.123456"}, [3]interface{}{sql.RawBytes("0.000000"), rbNULL, sql.RawBytes("1234.123456")}},
|
||||
{"decimal2", "DECIMAL(8,4) NOT NULL", "DECIMAL", scanTypeRawBytes, false, 8, 4, [3]string{"0", "13.37", "1234.123456"}, [3]interface{}{sql.RawBytes("0.0000"), sql.RawBytes("13.3700"), sql.RawBytes("1234.1235")}},
|
||||
{"decimal2null", "DECIMAL(8,4)", "DECIMAL", scanTypeRawBytes, true, 8, 4, [3]string{"0", "NULL", "1234.123456"}, [3]interface{}{sql.RawBytes("0.0000"), rbNULL, sql.RawBytes("1234.1235")}},
|
||||
{"decimal3", "DECIMAL(5,0) NOT NULL", "DECIMAL", scanTypeRawBytes, false, 5, 0, [3]string{"0", "13.37", "-12345.123456"}, [3]interface{}{rb0, sql.RawBytes("13"), sql.RawBytes("-12345")}},
|
||||
{"decimal3null", "DECIMAL(5,0)", "DECIMAL", scanTypeRawBytes, true, 5, 0, [3]string{"0", "NULL", "-12345.123456"}, [3]interface{}{rb0, rbNULL, sql.RawBytes("-12345")}},
|
||||
{"char25null", "CHAR(25)", "CHAR", scanTypeRawBytes, true, 0, 0, [3]string{"0", "NULL", "'Test'"}, [3]interface{}{rb0, rbNULL, rbTest}},
|
||||
{"varchar42", "VARCHAR(42) NOT NULL", "VARCHAR", scanTypeRawBytes, false, 0, 0, [3]string{"0", "'Test'", "42"}, [3]interface{}{rb0, rbTest, rb42}},
|
||||
{"binary4null", "BINARY(4)", "BINARY", scanTypeRawBytes, true, 0, 0, [3]string{"0", "NULL", "'Test'"}, [3]interface{}{rb0pad4, rbNULL, rbTest}},
|
||||
{"varbinary42", "VARBINARY(42) NOT NULL", "VARBINARY", scanTypeRawBytes, false, 0, 0, [3]string{"0", "'Test'", "42"}, [3]interface{}{rb0, rbTest, rb42}},
|
||||
{"tinyblobnull", "TINYBLOB", "BLOB", scanTypeRawBytes, true, 0, 0, [3]string{"0", "NULL", "'Test'"}, [3]interface{}{rb0, rbNULL, rbTest}},
|
||||
{"tinytextnull", "TINYTEXT", "TEXT", scanTypeRawBytes, true, 0, 0, [3]string{"0", "NULL", "'Test'"}, [3]interface{}{rb0, rbNULL, rbTest}},
|
||||
{"blobnull", "BLOB", "BLOB", scanTypeRawBytes, true, 0, 0, [3]string{"0", "NULL", "'Test'"}, [3]interface{}{rb0, rbNULL, rbTest}},
|
||||
{"textnull", "TEXT", "TEXT", scanTypeRawBytes, true, 0, 0, [3]string{"0", "NULL", "'Test'"}, [3]interface{}{rb0, rbNULL, rbTest}},
|
||||
{"mediumblob", "MEDIUMBLOB NOT NULL", "BLOB", scanTypeRawBytes, false, 0, 0, [3]string{"0", "'Test'", "42"}, [3]interface{}{rb0, rbTest, rb42}},
|
||||
{"mediumtext", "MEDIUMTEXT NOT NULL", "TEXT", scanTypeRawBytes, false, 0, 0, [3]string{"0", "'Test'", "42"}, [3]interface{}{rb0, rbTest, rb42}},
|
||||
{"longblob", "LONGBLOB NOT NULL", "BLOB", scanTypeRawBytes, false, 0, 0, [3]string{"0", "'Test'", "42"}, [3]interface{}{rb0, rbTest, rb42}},
|
||||
{"longtext", "LONGTEXT NOT NULL", "TEXT", scanTypeRawBytes, false, 0, 0, [3]string{"0", "'Test'", "42"}, [3]interface{}{rb0, rbTest, rb42}},
|
||||
{"datetime", "DATETIME", "DATETIME", scanTypeNullTime, true, 0, 0, [3]string{"'2006-01-02 15:04:05'", "'2006-01-02 15:04:05.1'", "'2006-01-02 15:04:05.111111'"}, [3]interface{}{nt0, nt0, nt0}},
|
||||
{"datetime2", "DATETIME(2)", "DATETIME", scanTypeNullTime, true, 2, 2, [3]string{"'2006-01-02 15:04:05'", "'2006-01-02 15:04:05.1'", "'2006-01-02 15:04:05.111111'"}, [3]interface{}{nt0, nt1, nt2}},
|
||||
{"datetime6", "DATETIME(6)", "DATETIME", scanTypeNullTime, true, 6, 6, [3]string{"'2006-01-02 15:04:05'", "'2006-01-02 15:04:05.1'", "'2006-01-02 15:04:05.111111'"}, [3]interface{}{nt0, nt1, nt6}},
|
||||
{"date", "DATE", "DATE", scanTypeNullTime, true, 0, 0, [3]string{"'2006-01-02'", "NULL", "'2006-03-04'"}, [3]interface{}{nd1, ndNULL, nd2}},
|
||||
{"year", "YEAR NOT NULL", "YEAR", scanTypeUint16, false, 0, 0, [3]string{"2006", "2000", "1994"}, [3]interface{}{uint16(2006), uint16(2000), uint16(1994)}},
|
||||
}
|
||||
|
||||
schema := ""
|
||||
values1 := ""
|
||||
values2 := ""
|
||||
values3 := ""
|
||||
for _, column := range columns {
|
||||
schema += fmt.Sprintf("`%s` %s, ", column.name, column.fieldType)
|
||||
values1 += column.valuesIn[0] + ", "
|
||||
values2 += column.valuesIn[1] + ", "
|
||||
values3 += column.valuesIn[2] + ", "
|
||||
}
|
||||
schema = schema[:len(schema)-2]
|
||||
values1 = values1[:len(values1)-2]
|
||||
values2 = values2[:len(values2)-2]
|
||||
values3 = values3[:len(values3)-2]
|
||||
|
||||
dsns := []string{
|
||||
dsn + "&parseTime=true",
|
||||
dsn + "&parseTime=false",
|
||||
}
|
||||
for _, testdsn := range dsns {
|
||||
runTests(t, testdsn, func(dbt *DBTest) {
|
||||
dbt.mustExec("CREATE TABLE test (" + schema + ")")
|
||||
dbt.mustExec("INSERT INTO test VALUES (" + values1 + "), (" + values2 + "), (" + values3 + ")")
|
||||
|
||||
rows, err := dbt.db.Query("SELECT * FROM test")
|
||||
if err != nil {
|
||||
t.Fatalf("Query: %v", err)
|
||||
}
|
||||
|
||||
tt, err := rows.ColumnTypes()
|
||||
if err != nil {
|
||||
t.Fatalf("ColumnTypes: %v", err)
|
||||
}
|
||||
|
||||
if len(tt) != len(columns) {
|
||||
t.Fatalf("unexpected number of columns: expected %d, got %d", len(columns), len(tt))
|
||||
}
|
||||
|
||||
types := make([]reflect.Type, len(tt))
|
||||
for i, tp := range tt {
|
||||
column := columns[i]
|
||||
|
||||
// Name
|
||||
name := tp.Name()
|
||||
if name != column.name {
|
||||
t.Errorf("column name mismatch %s != %s", name, column.name)
|
||||
continue
|
||||
}
|
||||
|
||||
// DatabaseTypeName
|
||||
databaseTypeName := tp.DatabaseTypeName()
|
||||
if databaseTypeName != column.databaseTypeName {
|
||||
t.Errorf("databasetypename name mismatch for column %q: %s != %s", name, databaseTypeName, column.databaseTypeName)
|
||||
continue
|
||||
}
|
||||
|
||||
// ScanType
|
||||
scanType := tp.ScanType()
|
||||
if scanType != column.scanType {
|
||||
if scanType == nil {
|
||||
t.Errorf("scantype is null for column %q", name)
|
||||
} else {
|
||||
t.Errorf("scantype mismatch for column %q: %s != %s", name, scanType.Name(), column.scanType.Name())
|
||||
}
|
||||
continue
|
||||
}
|
||||
types[i] = scanType
|
||||
|
||||
// Nullable
|
||||
nullable, ok := tp.Nullable()
|
||||
if !ok {
|
||||
t.Errorf("nullable not ok %q", name)
|
||||
continue
|
||||
}
|
||||
if nullable != column.nullable {
|
||||
t.Errorf("nullable mismatch for column %q: %t != %t", name, nullable, column.nullable)
|
||||
}
|
||||
|
||||
// Length
|
||||
// length, ok := tp.Length()
|
||||
// if length != column.length {
|
||||
// if !ok {
|
||||
// t.Errorf("length not ok for column %q", name)
|
||||
// } else {
|
||||
// t.Errorf("length mismatch for column %q: %d != %d", name, length, column.length)
|
||||
// }
|
||||
// continue
|
||||
// }
|
||||
|
||||
// Precision and Scale
|
||||
precision, scale, ok := tp.DecimalSize()
|
||||
if precision != column.precision {
|
||||
if !ok {
|
||||
t.Errorf("precision not ok for column %q", name)
|
||||
} else {
|
||||
t.Errorf("precision mismatch for column %q: %d != %d", name, precision, column.precision)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if scale != column.scale {
|
||||
if !ok {
|
||||
t.Errorf("scale not ok for column %q", name)
|
||||
} else {
|
||||
t.Errorf("scale mismatch for column %q: %d != %d", name, scale, column.scale)
|
||||
}
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
values := make([]interface{}, len(tt))
|
||||
for i := range values {
|
||||
values[i] = reflect.New(types[i]).Interface()
|
||||
}
|
||||
i := 0
|
||||
for rows.Next() {
|
||||
err = rows.Scan(values...)
|
||||
if err != nil {
|
||||
t.Fatalf("failed to scan values in %v", err)
|
||||
}
|
||||
for j := range values {
|
||||
value := reflect.ValueOf(values[j]).Elem().Interface()
|
||||
if !reflect.DeepEqual(value, columns[j].valuesOut[i]) {
|
||||
if columns[j].scanType == scanTypeRawBytes {
|
||||
t.Errorf("row %d, column %d: %v != %v", i, j, string(value.(sql.RawBytes)), string(columns[j].valuesOut[i].(sql.RawBytes)))
|
||||
} else {
|
||||
t.Errorf("row %d, column %d: %v != %v", i, j, value, columns[j].valuesOut[i])
|
||||
}
|
||||
}
|
||||
}
|
||||
i++
|
||||
}
|
||||
if i != 3 {
|
||||
t.Errorf("expected 3 rows, got %d", i)
|
||||
}
|
||||
|
||||
if err := rows.Close(); err != nil {
|
||||
t.Errorf("error closing rows: %s", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue