3601392501

Build Type

push

github

Committed by GitHub

Commit Message

update changelog for Version 1.7 (#1376)

Run Details

2932 of 3584 relevant lines covered (81.81%)

1490385.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.21

/fields.go

// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
//
// Copyright 2017 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 (
        "database/sql"
        "reflect"
)

func (mf *mysqlField) typeDatabaseName() string {
        switch mf.fieldType {
        case fieldTypeBit:
                return "BIT"
        case fieldTypeBLOB:
                if mf.charSet != collations[binaryCollation] {
                        return "TEXT"
                }
                return "BLOB"
        case fieldTypeDate:
                return "DATE"
        case fieldTypeDateTime:
                return "DATETIME"
        case fieldTypeDecimal:
                return "DECIMAL"
        case fieldTypeDouble:
                return "DOUBLE"
        case fieldTypeEnum:
                return "ENUM"
        case fieldTypeFloat:
                return "FLOAT"
        case fieldTypeGeometry:
                return "GEOMETRY"
        case fieldTypeInt24:
                return "MEDIUMINT"
        case fieldTypeJSON:
                return "JSON"
        case fieldTypeLong:
                if mf.flags&flagUnsigned != 0 {
                        return "UNSIGNED INT"
                }
                return "INT"
        case fieldTypeLongBLOB:
                if mf.charSet != collations[binaryCollation] {
                        return "LONGTEXT"
                }
                return "LONGBLOB"
        case fieldTypeLongLong:
                if mf.flags&flagUnsigned != 0 {
                        return "UNSIGNED BIGINT"
                }
                return "BIGINT"
        case fieldTypeMediumBLOB:
                if mf.charSet != collations[binaryCollation] {
                        return "MEDIUMTEXT"
                }
                return "MEDIUMBLOB"
        case fieldTypeNewDate:
                return "DATE"
        case fieldTypeNewDecimal:
                return "DECIMAL"
        case fieldTypeNULL:
                return "NULL"
        case fieldTypeSet:
                return "SET"
        case fieldTypeShort:
                if mf.flags&flagUnsigned != 0 {
                        return "UNSIGNED SMALLINT"
                }
                return "SMALLINT"
        case fieldTypeString:
                if mf.charSet == collations[binaryCollation] {
                        return "BINARY"
                }
                return "CHAR"
        case fieldTypeTime:
                return "TIME"
        case fieldTypeTimestamp:
                return "TIMESTAMP"
        case fieldTypeTiny:
                if mf.flags&flagUnsigned != 0 {
                        return "UNSIGNED TINYINT"
                }
                return "TINYINT"
        case fieldTypeTinyBLOB:
                if mf.charSet != collations[binaryCollation] {
                        return "TINYTEXT"
                }
                return "TINYBLOB"
        case fieldTypeVarChar:
                if mf.charSet == collations[binaryCollation] {
                        return "VARBINARY"
                }
                return "VARCHAR"
        case fieldTypeVarString:
                if mf.charSet == collations[binaryCollation] {
                        return "VARBINARY"
                }
                return "VARCHAR"
        case fieldTypeYear:
                return "YEAR"
        default:
                return ""
        }
}

var (
        scanTypeFloat32   = reflect.TypeOf(float32(0))
        scanTypeFloat64   = reflect.TypeOf(float64(0))
        scanTypeInt8      = reflect.TypeOf(int8(0))
        scanTypeInt16     = reflect.TypeOf(int16(0))
        scanTypeInt32     = reflect.TypeOf(int32(0))
        scanTypeInt64     = reflect.TypeOf(int64(0))
        scanTypeNullFloat = reflect.TypeOf(sql.NullFloat64{})
        scanTypeNullInt   = reflect.TypeOf(sql.NullInt64{})
        scanTypeNullTime  = reflect.TypeOf(sql.NullTime{})
        scanTypeUint8     = reflect.TypeOf(uint8(0))
        scanTypeUint16    = reflect.TypeOf(uint16(0))
        scanTypeUint32    = reflect.TypeOf(uint32(0))
        scanTypeUint64    = reflect.TypeOf(uint64(0))
        scanTypeRawBytes  = reflect.TypeOf(sql.RawBytes{})
        scanTypeUnknown   = reflect.TypeOf(new(interface{}))
)

type mysqlField struct {
        tableName string
        name      string
        length    uint32
        flags     fieldFlag
        fieldType fieldType
        decimals  byte
        charSet   uint8
}

func (mf *mysqlField) scanType() reflect.Type {
        switch mf.fieldType {
        case fieldTypeTiny:
                if mf.flags&flagNotNULL != 0 {
                        if mf.flags&flagUnsigned != 0 {
                                return scanTypeUint8
                        }
                        return scanTypeInt8
                }
                return scanTypeNullInt

        case fieldTypeShort, fieldTypeYear:
                if mf.flags&flagNotNULL != 0 {
                        if mf.flags&flagUnsigned != 0 {
                                return scanTypeUint16
                        }
                        return scanTypeInt16
                }
                return scanTypeNullInt

        case fieldTypeInt24, fieldTypeLong:
                if mf.flags&flagNotNULL != 0 {
                        if mf.flags&flagUnsigned != 0 {
                                return scanTypeUint32
                        }
                        return scanTypeInt32
                }
                return scanTypeNullInt

        case fieldTypeLongLong:
                if mf.flags&flagNotNULL != 0 {
                        if mf.flags&flagUnsigned != 0 {
                                return scanTypeUint64
                        }
                        return scanTypeInt64
                }
                return scanTypeNullInt

        case fieldTypeFloat:
                if mf.flags&flagNotNULL != 0 {
                        return scanTypeFloat32
                }
                return scanTypeNullFloat

        case fieldTypeDouble:
                if mf.flags&flagNotNULL != 0 {
                        return scanTypeFloat64
                }
                return scanTypeNullFloat

        case fieldTypeDecimal, fieldTypeNewDecimal, fieldTypeVarChar,
                fieldTypeBit, fieldTypeEnum, fieldTypeSet, fieldTypeTinyBLOB,
                fieldTypeMediumBLOB, fieldTypeLongBLOB, fieldTypeBLOB,
                fieldTypeVarString, fieldTypeString, fieldTypeGeometry, fieldTypeJSON,
                fieldTypeTime:
                return scanTypeRawBytes

        case fieldTypeDate, fieldTypeNewDate,
                fieldTypeTimestamp, fieldTypeDateTime:
                // NullTime is always returned for more consistent behavior as it can
                // handle both cases of parseTime regardless if the field is nullable.
                return scanTypeNullTime

        default:
                return scanTypeUnknown
        }
}

1	// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2	//
3	// Copyright 2017 The Go-MySQL-Driver Authors. All rights reserved.
4	//
5	// This Source Code Form is subject to the terms of the Mozilla Public
6	// License, v. 2.0. If a copy of the MPL was not distributed with this file,
7	// You can obtain one at http://mozilla.org/MPL/2.0/.
8
9	package mysql
10
11	import (
12	"database/sql"
13	"reflect"
14	)
15
16	func (mf *mysqlField) typeDatabaseName() string {	3,483✔
17	switch mf.fieldType {	3,483✔
18	case fieldTypeBit:	81✔
19	return "BIT"	81✔
20	case fieldTypeBLOB:	648✔
21	if mf.charSet != collations[binaryCollation] {	972✔
22	return "TEXT"	324✔
23	}	324✔
24	return "BLOB"	324✔
25	case fieldTypeDate:	81✔
26	return "DATE"	81✔
27	case fieldTypeDateTime:	243✔
28	return "DATETIME"	243✔
29	case fieldTypeDecimal:	×
30	return "DECIMAL"	×
31	case fieldTypeDouble:	162✔
32	return "DOUBLE"	162✔
33	case fieldTypeEnum:	×
34	return "ENUM"	×
35	case fieldTypeFloat:	243✔
36	return "FLOAT"	243✔
37	case fieldTypeGeometry:	×
38	return "GEOMETRY"	×
39	case fieldTypeInt24:	81✔
40	return "MEDIUMINT"	81✔
41	case fieldTypeJSON:	×
42	return "JSON"	×
43	case fieldTypeLong:	324✔
44	if mf.flags&flagUnsigned != 0 {	405✔
45	return "UNSIGNED INT"	81✔
46	}	81✔
47	return "INT"	243✔
48	case fieldTypeLongBLOB:	×
49	if mf.charSet != collations[binaryCollation] {	×
50	return "LONGTEXT"	×
51	}	×
52	return "LONGBLOB"	×
53	case fieldTypeLongLong:	243✔
54	if mf.flags&flagUnsigned != 0 {	324✔
55	return "UNSIGNED BIGINT"	81✔
56	}	81✔
57	return "BIGINT"	162✔
58	case fieldTypeMediumBLOB:	×
59	if mf.charSet != collations[binaryCollation] {	×
60	return "MEDIUMTEXT"	×
61	}	×
62	return "MEDIUMBLOB"	×
63	case fieldTypeNewDate:	×
64	return "DATE"	×
65	case fieldTypeNewDecimal:	486✔
66	return "DECIMAL"	486✔
67	case fieldTypeNULL:	×
68	return "NULL"	×
69	case fieldTypeSet:	×
70	return "SET"	×
71	case fieldTypeShort:	243✔
72	if mf.flags&flagUnsigned != 0 {	324✔
73	return "UNSIGNED SMALLINT"	81✔
74	}	81✔
75	return "SMALLINT"	162✔
76	case fieldTypeString:	162✔
77	if mf.charSet == collations[binaryCollation] {	243✔
78	return "BINARY"	81✔
79	}	81✔
80	return "CHAR"	81✔
81	case fieldTypeTime:	×
82	return "TIME"	×
83	case fieldTypeTimestamp:	×
84	return "TIMESTAMP"	×
85	case fieldTypeTiny:	243✔
86	if mf.flags&flagUnsigned != 0 {	324✔
87	return "UNSIGNED TINYINT"	81✔
88	}	81✔
89	return "TINYINT"	162✔
90	case fieldTypeTinyBLOB:	×
91	if mf.charSet != collations[binaryCollation] {	×
92	return "TINYTEXT"	×
93	}	×
94	return "TINYBLOB"	×
95	case fieldTypeVarChar:	×
96	if mf.charSet == collations[binaryCollation] {	×
97	return "VARBINARY"	×
98	}	×
99	return "VARCHAR"	×
100	case fieldTypeVarString:	162✔
101	if mf.charSet == collations[binaryCollation] {	243✔
102	return "VARBINARY"	81✔
103	}	81✔
104	return "VARCHAR"	81✔
105	case fieldTypeYear:	81✔
106	return "YEAR"	81✔
107	default:	×
108	return ""	×
109	}
110	}
111
112	var (
113	scanTypeFloat32 = reflect.TypeOf(float32(0))
114	scanTypeFloat64 = reflect.TypeOf(float64(0))
115	scanTypeInt8 = reflect.TypeOf(int8(0))
116	scanTypeInt16 = reflect.TypeOf(int16(0))
117	scanTypeInt32 = reflect.TypeOf(int32(0))
118	scanTypeInt64 = reflect.TypeOf(int64(0))
119	scanTypeNullFloat = reflect.TypeOf(sql.NullFloat64{})
120	scanTypeNullInt = reflect.TypeOf(sql.NullInt64{})
121	scanTypeNullTime = reflect.TypeOf(sql.NullTime{})
122	scanTypeUint8 = reflect.TypeOf(uint8(0))
123	scanTypeUint16 = reflect.TypeOf(uint16(0))
124	scanTypeUint32 = reflect.TypeOf(uint32(0))
125	scanTypeUint64 = reflect.TypeOf(uint64(0))
126	scanTypeRawBytes = reflect.TypeOf(sql.RawBytes{})
127	scanTypeUnknown = reflect.TypeOf(new(interface{}))
128	)
129
130	type mysqlField struct {
131	tableName string
132	name string
133	length uint32
134	flags fieldFlag
135	fieldType fieldType
136	decimals byte
137	charSet uint8
138	}
139
140	func (mf *mysqlField) scanType() reflect.Type {	3,483✔
141	switch mf.fieldType {	3,483✔
142	case fieldTypeTiny:	243✔
143	if mf.flags&flagNotNULL != 0 {	405✔
144	if mf.flags&flagUnsigned != 0 {	243✔
145	return scanTypeUint8	81✔
146	}	81✔
147	return scanTypeInt8	81✔
148	}
149	return scanTypeNullInt	81✔
150
151	case fieldTypeShort, fieldTypeYear:	324✔
152	if mf.flags&flagNotNULL != 0 {	567✔
153	if mf.flags&flagUnsigned != 0 {	405✔
154	return scanTypeUint16	162✔
155	}	162✔
156	return scanTypeInt16	81✔
157	}
158	return scanTypeNullInt	81✔
159
160	case fieldTypeInt24, fieldTypeLong:	405✔
161	if mf.flags&flagNotNULL != 0 {	567✔
162	if mf.flags&flagUnsigned != 0 {	243✔
163	return scanTypeUint32	81✔
164	}	81✔
165	return scanTypeInt32	81✔
166	}
167	return scanTypeNullInt	243✔
168
169	case fieldTypeLongLong:	243✔
170	if mf.flags&flagNotNULL != 0 {	405✔
171	if mf.flags&flagUnsigned != 0 {	243✔
172	return scanTypeUint64	81✔
173	}	81✔
174	return scanTypeInt64	81✔
175	}
176	return scanTypeNullInt	81✔
177
178	case fieldTypeFloat:	243✔
179	if mf.flags&flagNotNULL != 0 {	324✔
180	return scanTypeFloat32	81✔
181	}	81✔
182	return scanTypeNullFloat	162✔
183
184	case fieldTypeDouble:	162✔
185	if mf.flags&flagNotNULL != 0 {	243✔
186	return scanTypeFloat64	81✔
187	}	81✔
188	return scanTypeNullFloat	81✔
189
190	case fieldTypeDecimal, fieldTypeNewDecimal, fieldTypeVarChar,
191	fieldTypeBit, fieldTypeEnum, fieldTypeSet, fieldTypeTinyBLOB,
192	fieldTypeMediumBLOB, fieldTypeLongBLOB, fieldTypeBLOB,
193	fieldTypeVarString, fieldTypeString, fieldTypeGeometry, fieldTypeJSON,
194	fieldTypeTime:	1,539✔
195	return scanTypeRawBytes	1,539✔
196
197	case fieldTypeDate, fieldTypeNewDate,
198	fieldTypeTimestamp, fieldTypeDateTime:	324✔
199	// NullTime is always returned for more consistent behavior as it can	324✔
200	// handle both cases of parseTime regardless if the field is nullable.	324✔
201	return scanTypeNullTime	324✔
202
203	default:	×
204	return scanTypeUnknown	×
205	}
206	}

go-sql-driver / mysql / 3601392501

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous