func (t *Table) unflatten(rec interface{}, col *column.Col) (interface{}, error) { if rec == nil { return nil, nil } switch col.Tp { case mysql.TypeFloat: return float32(rec.(float64)), nil case mysql.TypeTiny, mysql.TypeShort, mysql.TypeYear, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong, mysql.TypeDouble, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeBlob, mysql.TypeLongBlob, mysql.TypeVarchar, mysql.TypeString: return rec, nil case mysql.TypeDate, mysql.TypeDatetime, mysql.TypeTimestamp: var t mysql.Time t.Type = col.Tp t.Fsp = col.Decimal err := t.Unmarshal(rec.([]byte)) if err != nil { return nil, errors.Trace(err) } return t, nil case mysql.TypeDuration: return mysql.Duration{Duration: time.Duration(rec.(int64)), Fsp: col.Decimal}, nil case mysql.TypeNewDecimal, mysql.TypeDecimal: return mysql.ParseDecimal(rec.(string)) case mysql.TypeEnum: return mysql.ParseEnumValue(col.Elems, rec.(uint64)) case mysql.TypeSet: return mysql.ParseSetValue(col.Elems, rec.(uint64)) case mysql.TypeBit: return mysql.Bit{Value: rec.(uint64), Width: col.Flen}, nil } log.Error(col.Tp, rec, reflect.TypeOf(rec)) return nil, nil }
func (t *Table) unflatten(rec interface{}, col *column.Col) (interface{}, error) { if rec == nil { return nil, nil } switch col.Tp { case mysql.TypeFloat: return float32(rec.(float64)), nil case mysql.TypeDouble: return rec.(float64), nil case mysql.TypeTiny: if mysql.HasUnsignedFlag(col.Flag) { return uint8(rec.(uint64)), nil } return int8(rec.(int64)), nil case mysql.TypeShort, mysql.TypeYear: if mysql.HasUnsignedFlag(col.Flag) { return uint16(rec.(uint64)), nil } return int16(rec.(int64)), nil case mysql.TypeInt24, mysql.TypeLong: if mysql.HasUnsignedFlag(col.Flag) { return uint32(rec.(uint64)), nil } return int32(rec.(int64)), nil case mysql.TypeLonglong: if mysql.HasUnsignedFlag(col.Flag) { return rec.(uint64), nil } return rec.(int64), nil case mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeBlob, mysql.TypeLongBlob, mysql.TypeVarchar, mysql.TypeString: return rec, nil case mysql.TypeDate, mysql.TypeDatetime, mysql.TypeTimestamp: var t mysql.Time t.Type = col.Tp t.Fsp = col.Decimal err := t.Unmarshal(rec.([]byte)) if err != nil { return nil, errors.Trace(err) } return t, nil case mysql.TypeDuration: return mysql.Duration{Duration: time.Duration(rec.(int64)), Fsp: col.Decimal}, nil case mysql.TypeNewDecimal, mysql.TypeDecimal: return mysql.ParseDecimal(rec.(string)) } log.Error(string(col.Tp), rec, reflect.TypeOf(rec)) return nil, nil }
func (s *testCodecSuite) TestDecimal(c *C) { tbl := []string{ "1234.00", "1234", "12.34", "12.340", "0.1234", "0.0", "0", "-0.0", "-0.0000", "-1234.00", "-1234", "-12.34", "-12.340", "-0.1234"} for _, t := range tbl { m, err := mysql.ParseDecimal(t) c.Assert(err, IsNil) b, err := EncodeKey(m) c.Assert(err, IsNil) v, err := DecodeKey(b) c.Assert(err, IsNil) c.Assert(v, HasLen, 1) vv, ok := v[0].(mysql.Decimal) c.Assert(ok, IsTrue) c.Assert(vv.Equals(m), IsTrue) } tblCmp := []struct { Arg1 interface{} Arg2 interface{} Ret int }{ // Test for float type decimal. {"1234", "123400", -1}, {"12340", "123400", -1}, {"1234", "1234.5", -1}, {"1234", "1234.0000", 0}, {"1234", "12.34", 1}, {"12.34", "12.35", -1}, {"0.1234", "12.3400", -1}, {"0.1234", "0.1235", -1}, {"0.123400", "12.34", -1}, {"12.34000", "12.34", 0}, {"0.01234", "0.01235", -1}, {"0.1234", "0", 1}, {"0.0000", "0", 0}, {"0.0001", "0", 1}, {"0.0001", "0.0000", 1}, {"0", "-0.0000", 0}, {"-0.0001", "0", -1}, {"-0.1234", "0", -1}, {"-0.1234", "0.1234", -1}, {"-1.234", "-12.34", 1}, {"-0.1234", "-12.34", 1}, {"-12.34", "1234", -1}, {"-12.34", "-12.35", 1}, {"-0.01234", "-0.01235", 1}, {"-1234", "-123400", 1}, {"-12340", "-123400", 1}, // Test for int type decimal. {int64(-1), int64(1), -1}, {int64(math.MaxInt64), int64(math.MinInt64), 1}, {int64(math.MaxInt64), int64(math.MaxInt32), 1}, {int64(math.MinInt32), int64(math.MaxInt16), -1}, {int64(math.MinInt64), int64(math.MaxInt8), -1}, {int64(0), int64(math.MaxInt8), -1}, {int64(math.MinInt8), int64(0), -1}, {int64(math.MinInt16), int64(math.MaxInt16), -1}, {int64(1), int64(-1), 1}, {int64(1), int64(0), 1}, {int64(-1), int64(0), -1}, {int64(0), int64(0), 0}, {int64(math.MaxInt16), int64(math.MaxInt16), 0}, // Test for uint type decimal. {uint64(0), uint64(0), 0}, {uint64(1), uint64(0), 1}, {uint64(0), uint64(1), -1}, {uint64(math.MaxInt8), uint64(math.MaxInt16), -1}, {uint64(math.MaxUint32), uint64(math.MaxInt32), 1}, {uint64(math.MaxUint8), uint64(math.MaxInt8), 1}, {uint64(math.MaxUint16), uint64(math.MaxInt32), -1}, {uint64(math.MaxUint64), uint64(math.MaxInt64), 1}, {uint64(math.MaxInt64), uint64(math.MaxUint32), 1}, {uint64(math.MaxUint64), uint64(0), 1}, {uint64(0), uint64(math.MaxUint64), -1}, } for _, t := range tblCmp { m1, err := mysql.ConvertToDecimal(t.Arg1) c.Assert(err, IsNil) m2, err := mysql.ConvertToDecimal(t.Arg2) c.Assert(err, IsNil) b1, err := EncodeKey(m1) c.Assert(err, IsNil) b2, err := EncodeKey(m2) c.Assert(err, IsNil) ret := bytes.Compare(b1, b2) c.Assert(ret, Equals, t.Ret) } }
// CastValue casts a value based on column's type. func (c *Col) CastValue(ctx context.Context, val interface{}) (casted interface{}, err error) { if val == nil { return } switch c.Tp { case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong, mysql.TypeYear, mysql.TypeBit: intVal, errCode := c.normalizeIntegerValue(val) if errCode == errCodeType { casted = intVal err = c.TypeError(val) return } return c.castIntegerValue(intVal, errCode) case mysql.TypeFloat, mysql.TypeDouble: return c.castFloatValue(val) case mysql.TypeDate, mysql.TypeDatetime, mysql.TypeTimestamp: switch v := val.(type) { case int64: casted, err = mysql.ParseTimeFromNum(v, c.Tp, c.Decimal) if err != nil { err = newParseColError(err, c) } case string: casted, err = mysql.ParseTime(v, c.Tp, c.Decimal) if err != nil { err = newParseColError(err, c) } case mysql.Time: var t mysql.Time t, err = v.Convert(c.Tp) if err != nil { err = newParseColError(err, c) return } casted, err = t.RoundFrac(c.Decimal) if err != nil { err = newParseColError(err, c) } default: err = c.TypeError(val) } case mysql.TypeDuration: switch v := val.(type) { case string: casted, err = mysql.ParseDuration(v, c.Decimal) if err != nil { err = newParseColError(err, c) } case mysql.Time: var t mysql.Duration t, err = v.ConvertToDuration() if err != nil { err = newParseColError(err, c) return } casted, err = t.RoundFrac(c.Decimal) if err != nil { err = newParseColError(err, c) } case mysql.Duration: casted, err = v.RoundFrac(c.Decimal) default: err = c.TypeError(val) } case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob, mysql.TypeString, mysql.TypeVarchar, mysql.TypeVarString: strV := "" switch v := val.(type) { case mysql.Time: strV = v.String() case mysql.Duration: strV = v.String() case []byte: if c.Charset == charset.CharsetBin { casted = v return } strV = string(v) default: strV = fmt.Sprintf("%v", val) } if (c.Flen != types.UnspecifiedLength) && (len(strV) > c.Flen) { strV = strV[:c.Flen] } casted = strV case mysql.TypeDecimal, mysql.TypeNewDecimal: switch v := val.(type) { case string: casted, err = mysql.ParseDecimal(v) if err != nil { err = newParseColError(err, c) } case int8: casted = mysql.NewDecimalFromInt(int64(v), 0) case int16: casted = mysql.NewDecimalFromInt(int64(v), 0) case int32: casted = mysql.NewDecimalFromInt(int64(v), 0) case int64: casted = mysql.NewDecimalFromInt(int64(v), 0) case int: casted = mysql.NewDecimalFromInt(int64(v), 0) case uint8: casted = mysql.NewDecimalFromUint(uint64(v), 0) case uint16: casted = mysql.NewDecimalFromUint(uint64(v), 0) case uint32: casted = mysql.NewDecimalFromUint(uint64(v), 0) case uint64: casted = mysql.NewDecimalFromUint(uint64(v), 0) case uint: casted = mysql.NewDecimalFromUint(uint64(v), 0) case float32: casted = mysql.NewDecimalFromFloat(float64(v)) case float64: casted = mysql.NewDecimalFromFloat(float64(v)) case mysql.Decimal: casted = v } default: err = c.TypeError(val) } return }
// DecodeDecimal decodes bytes to decimal. // DecodeFloat decodes a float from a byte slice // Decimal decoding: // DecodeInt -> value sign // DecodeInt -> exp sign // DecodeInt -> exp value // DecodeBytes -> abs value bytes func DecodeDecimal(b []byte) ([]byte, mysql.Decimal, error) { var ( r []byte d mysql.Decimal err error ) // Decode value sign. valSign := zeroSign r, valSign, err = DecodeInt(b) if err != nil { return r, d, errors.Trace(err) } if valSign == zeroSign { d, err = mysql.ParseDecimal("0") return r, d, errors.Trace(err) } // Decode exp sign. expSign := zeroSign r, expSign, err = DecodeInt(r) if err != nil { return r, d, errors.Trace(err) } // Decode exp value. expVal := int64(0) r, expVal, err = DecodeInt(r) if err != nil { return r, d, errors.Trace(err) } expVal = decodeExp(expVal, expSign, valSign) // Decode abs value bytes. value := []byte{} r, value, err = DecodeBytes(r) if err != nil { return r, d, errors.Trace(err) } codecValue(value, valSign) // Generate decimal string value. var decimalStr []byte if valSign == negativeSign { decimalStr = append(decimalStr, '-') } if expVal <= 0 { // Like decimal "0.1234" or "0.01234". decimalStr = append(decimalStr, '0') decimalStr = append(decimalStr, '.') decimalStr = append(decimalStr, bytes.Repeat([]byte{'0'}, -int(expVal))...) decimalStr = append(decimalStr, value...) } else { // Like decimal "12.34". decimalStr = append(decimalStr, value[:expVal]...) decimalStr = append(decimalStr, '.') decimalStr = append(decimalStr, value[expVal:]...) } d, err = mysql.ParseDecimal(string(decimalStr)) return r, d, errors.Trace(err) }