func (s *testDecimalSuite) TestDecimalCodec(c *C) {
inputs := []struct {
Input float64
}{
{float64(123400)},
{float64(1234)},
{float64(12.34)},
{float64(0.1234)},
{float64(0.01234)},
{float64(-0.1234)},
{float64(-0.01234)},
{float64(12.3400)},
{float64(-12.34)},
{float64(0.00000)},
{float64(0)},
{float64(-0.0)},
{float64(-0.000)},
}
for _, input := range inputs {
v := mysql.NewDecimalFromFloat(input.Input)
b := EncodeDecimal([]byte{}, v)
_, d, err := DecodeDecimal(b)
c.Assert(err, IsNil)
c.Assert(v.Equals(d), IsTrue)
}
}
// Eval implements the Expression Eval interface.
func (u *UnaryOperation) Eval(ctx context.Context, args map[interface{}]interface{}) (r interface{}, err error) {
defer func() {
if e := recover(); e != nil {
r, err = nil, errors.Errorf("%v", e)
}
}()
switch op := u.Op; op {
case opcode.Not:
a := Eval(u.V, ctx, args)
if a == nil {
return
}
n, err := types.ToBool(a)
if err != nil {
return types.UndOp(a, op)
} else if n == 0 {
return int8(1), nil
}
return int8(0), nil
case opcode.BitNeg:
a := Eval(u.V, ctx, args)
if a == nil {
return
}
// for bit operation, we will use int64 first, then return uint64
n, err := types.ToInt64(a)
if err != nil {
return types.UndOp(a, op)
}
return uint64(^n), nil
case opcode.Plus:
a := Eval(u.V, ctx, args)
switch x := a.(type) {
case nil:
return nil, nil
case float32:
return +x, nil
case float64:
return +x, nil
case int:
return +x, nil
case int8:
return +x, nil
case int16:
return +x, nil
case int32:
return +x, nil
case int64:
return +x, nil
case uint:
return +x, nil
case uint8:
return +x, nil
case uint16:
return +x, nil
case uint32:
return +x, nil
case uint64:
return +x, nil
case mysql.Duration:
return x, nil
case mysql.Time:
return x, nil
case string:
return x, nil
case mysql.Decimal:
return x, nil
default:
return types.UndOp(a, op)
}
case opcode.Minus:
a := Eval(u.V, ctx, args)
switch x := a.(type) {
case nil:
return nil, nil
case float32:
return -x, nil
case float64:
return -x, nil
case int:
return -x, nil
case int8:
return -x, nil
case int16:
return -x, nil
case int32:
return -x, nil
case int64:
return -x, nil
case uint:
return -int64(x), nil
case uint8:
return -int64(x), nil
case uint16:
return -int64(x), nil
case uint32:
return -int64(x), nil
case uint64:
// TODO: check overflow and do more test for unsigned type
return -int64(x), nil
case mysql.Duration:
return mysql.ZeroDecimal.Sub(x.ToNumber()), nil
case mysql.Time:
return mysql.ZeroDecimal.Sub(x.ToNumber()), nil
case string:
f, err := types.StrToFloat(x)
return -f, err
case mysql.Decimal:
f, _ := x.Float64()
return mysql.NewDecimalFromFloat(-f), nil
default:
return types.UndOp(a, op)
}
default:
panic("should never happen")
}
}
// 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
}