Scanner should return one of int64,float64,bool,[]byte,string,time.Time,nil , but I got uint64  #1575

Activity

1. methane commented on Mar 25, 2024

   

   methane

   on Mar 25, 2024

   Member

   More actions

   Yes, it violates database/sql convention.
   But this violation is necessary to support uint64. So we can not fix it until database/sql supports uint64 natively.
2. bronze1man commented on Mar 26, 2024

   

   bronze1man

   on Mar 26, 2024

   Author

   More actions

   @methane Is there any document or examples about how to implement sql.Scanner to work with https://github.com/go-sql-driver/mysql?
   I do not like try and fail again and again.
3. methane commented on Mar 26, 2024

   

   methane

   on Mar 26, 2024

   Member

   More actions

   There is perfect document.

   https://cs.opensource.google/go/go/+/master:src/database/sql/convert.go;l=219-480

   mysql/packets.go

   Lines 769 to 856 in d7ddb8b

   	func (rows *textRows) readRow(dest []driver.Value) error {
   	mc := rows.mc
   	if rows.rs.done {
   	return io.EOF
   	}
   	data, err := mc.readPacket()
   	if err != nil {
   	return err
   	}
   	// EOF Packet
   	if data[0] == iEOF && len(data) == 5 {
   	// server_status [2 bytes]
   	rows.mc.status = readStatus(data[3:])
   	rows.rs.done = true
   	if !rows.HasNextResultSet() {
   	rows.mc = nil
   	}
   	return io.EOF
   	}
   	if data[0] == iERR {
   	rows.mc = nil
   	return mc.handleErrorPacket(data)
   	}
   	// RowSet Packet
   	var (
   	n int
   	isNull bool
   	pos int = 0
   	)
   	for i := range dest {
   	// Read bytes and convert to string
   	var buf []byte
   	buf, isNull, n, err = readLengthEncodedString(data[pos:])
   	pos += n
   	if err != nil {
   	return err
   	}
   	if isNull {
   	dest[i] = nil
   	continue
   	}
   	switch rows.rs.columns[i].fieldType {
   	case fieldTypeTimestamp,
   	fieldTypeDateTime,
   	fieldTypeDate,
   	fieldTypeNewDate:
   	if mc.parseTime {
   	dest[i], err = parseDateTime(buf, mc.cfg.Loc)
   	} else {
   	dest[i] = buf
   	}
   	case fieldTypeTiny, fieldTypeShort, fieldTypeInt24, fieldTypeYear, fieldTypeLong:
   	dest[i], err = strconv.ParseInt(string(buf), 10, 64)
   	case fieldTypeLongLong:
   	if rows.rs.columns[i].flags&flagUnsigned != 0 {
   	dest[i], err = strconv.ParseUint(string(buf), 10, 64)
   	} else {
   	dest[i], err = strconv.ParseInt(string(buf), 10, 64)
   	}
   	case fieldTypeFloat:
   	var d float64
   	d, err = strconv.ParseFloat(string(buf), 32)
   	dest[i] = float32(d)
   	case fieldTypeDouble:
   	dest[i], err = strconv.ParseFloat(string(buf), 64)
   	default:
   	dest[i] = buf
   	}
   	if err != nil {
   	return err
   	}
   	}
   	return nil
   	}

   mysql/packets.go

   Lines 1230 to 1403 in d7ddb8b

   	func (rows *binaryRows) readRow(dest []driver.Value) error {
   	data, err := rows.mc.readPacket()
   	if err != nil {
   	return err
   	}
   	// packet indicator [1 byte]
   	if data[0] != iOK {
   	// EOF Packet
   	if data[0] == iEOF && len(data) == 5 {
   	rows.mc.status = readStatus(data[3:])
   	rows.rs.done = true
   	if !rows.HasNextResultSet() {
   	rows.mc = nil
   	}
   	return io.EOF
   	}
   	mc := rows.mc
   	rows.mc = nil
   	// Error otherwise
   	return mc.handleErrorPacket(data)
   	}
   	// NULL-bitmap, [(column-count + 7 + 2) / 8 bytes]
   	pos := 1 + (len(dest)+7+2)>>3
   	nullMask := data[1:pos]
   	for i := range dest {
   	// Field is NULL
   	// (byte >> bit-pos) % 2 == 1
   	if ((nullMask[(i+2)>>3] >> uint((i+2)&7)) & 1) == 1 {
   	dest[i] = nil
   	continue
   	}
   	// Convert to byte-coded string
   	switch rows.rs.columns[i].fieldType {
   	case fieldTypeNULL:
   	dest[i] = nil
   	continue
   	// Numeric Types
   	case fieldTypeTiny:
   	if rows.rs.columns[i].flags&flagUnsigned != 0 {
   	dest[i] = int64(data[pos])
   	} else {
   	dest[i] = int64(int8(data[pos]))
   	}
   	pos++
   	continue
   	case fieldTypeShort, fieldTypeYear:
   	if rows.rs.columns[i].flags&flagUnsigned != 0 {
   	dest[i] = int64(binary.LittleEndian.Uint16(data[pos : pos+2]))
   	} else {
   	dest[i] = int64(int16(binary.LittleEndian.Uint16(data[pos : pos+2])))
   	}
   	pos += 2
   	continue
   	case fieldTypeInt24, fieldTypeLong:
   	if rows.rs.columns[i].flags&flagUnsigned != 0 {
   	dest[i] = int64(binary.LittleEndian.Uint32(data[pos : pos+4]))
   	} else {
   	dest[i] = int64(int32(binary.LittleEndian.Uint32(data[pos : pos+4])))
   	}
   	pos += 4
   	continue
   	case fieldTypeLongLong:
   	if rows.rs.columns[i].flags&flagUnsigned != 0 {
   	val := binary.LittleEndian.Uint64(data[pos : pos+8])
   	if val > math.MaxInt64 {
   	dest[i] = uint64ToString(val)
   	} else {
   	dest[i] = int64(val)
   	}
   	} else {
   	dest[i] = int64(binary.LittleEndian.Uint64(data[pos : pos+8]))
   	}
   	pos += 8
   	continue
   	case fieldTypeFloat:
   	dest[i] = math.Float32frombits(binary.LittleEndian.Uint32(data[pos : pos+4]))
   	pos += 4
   	continue
   	case fieldTypeDouble:
   	dest[i] = math.Float64frombits(binary.LittleEndian.Uint64(data[pos : pos+8]))
   	pos += 8
   	continue
   	// Length coded Binary Strings
   	case fieldTypeDecimal, fieldTypeNewDecimal, fieldTypeVarChar,
   	fieldTypeBit, fieldTypeEnum, fieldTypeSet, fieldTypeTinyBLOB,
   	fieldTypeMediumBLOB, fieldTypeLongBLOB, fieldTypeBLOB,
   	fieldTypeVarString, fieldTypeString, fieldTypeGeometry, fieldTypeJSON:
   	var isNull bool
   	var n int
   	dest[i], isNull, n, err = readLengthEncodedString(data[pos:])
   	pos += n
   	if err == nil {
   	if !isNull {
   	continue
   	} else {
   	dest[i] = nil
   	continue
   	}
   	}
   	return err
   	case
   	fieldTypeDate, fieldTypeNewDate, // Date YYYY-MM-DD
   	fieldTypeTime, // Time [-][H]HH:MM:SS[.fractal]
   	fieldTypeTimestamp, fieldTypeDateTime: // Timestamp YYYY-MM-DD HH:MM:SS[.fractal]
   	num, isNull, n := readLengthEncodedInteger(data[pos:])
   	pos += n
   	switch {
   	case isNull:
   	dest[i] = nil
   	continue
   	case rows.rs.columns[i].fieldType == fieldTypeTime:
   	// database/sql does not support an equivalent to TIME, return a string
   	var dstlen uint8
   	switch decimals := rows.rs.columns[i].decimals; decimals {
   	case 0x00, 0x1f:
   	dstlen = 8
   	case 1, 2, 3, 4, 5, 6:
   	dstlen = 8 + 1 + decimals
   	default:
   	return fmt.Errorf(
   	"protocol error, illegal decimals value %d",
   	rows.rs.columns[i].decimals,
   	)
   	}
   	dest[i], err = formatBinaryTime(data[pos:pos+int(num)], dstlen)
   	case rows.mc.parseTime:
   	dest[i], err = parseBinaryDateTime(num, data[pos:], rows.mc.cfg.Loc)
   	default:
   	var dstlen uint8
   	if rows.rs.columns[i].fieldType == fieldTypeDate {
   	dstlen = 10
   	} else {
   	switch decimals := rows.rs.columns[i].decimals; decimals {
   	case 0x00, 0x1f:
   	dstlen = 19
   	case 1, 2, 3, 4, 5, 6:
   	dstlen = 19 + 1 + decimals
   	default:
   	return fmt.Errorf(
   	"protocol error, illegal decimals value %d",
   	rows.rs.columns[i].decimals,
   	)
   	}
   	}
   	dest[i], err = formatBinaryDateTime(data[pos:pos+int(num)], dstlen)
   	}
   	if err == nil {
   	pos += int(num)
   	continue
   	} else {
   	return err
   	}
   	// Please report if this happens!
   	default:
   	return fmt.Errorf("unknown field type %d", rows.rs.columns[i].fieldType)
   	}
   	}

   It must be readable than my English.