You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1454 lines
46 KiB
1454 lines
46 KiB
// Copyright 2017 PingCAP, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package expression
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"time"
|
|
|
|
. "github.com/pingcap/check"
|
|
"github.com/pingcap/parser/charset"
|
|
"github.com/pingcap/parser/mysql"
|
|
"github.com/pingcap/parser/terror"
|
|
"github.com/pingcap/tidb/types"
|
|
"github.com/pingcap/tidb/types/json"
|
|
"github.com/pingcap/tidb/util/chunk"
|
|
"github.com/pingcap/tidb/util/mock"
|
|
)
|
|
|
|
func (s *testEvaluatorSuite) TestCastXXX(c *C) {
|
|
ctx, sc := s.ctx, s.ctx.GetSessionVars().StmtCtx
|
|
|
|
// Test `cast as char[(N)]` and `cast as binary[(N)]`.
|
|
originIgnoreTruncate := sc.IgnoreTruncate
|
|
originTruncateAsWarning := sc.TruncateAsWarning
|
|
sc.IgnoreTruncate = false
|
|
sc.TruncateAsWarning = true
|
|
defer func() {
|
|
sc.IgnoreTruncate = originIgnoreTruncate
|
|
sc.TruncateAsWarning = originTruncateAsWarning
|
|
}()
|
|
|
|
tp := types.NewFieldType(mysql.TypeString)
|
|
tp.Flen = 5
|
|
|
|
// cast(str as char(N)), N < len([]rune(str)).
|
|
// cast("你好world" as char(5))
|
|
tp.Charset = charset.CharsetUTF8
|
|
f := BuildCastFunction(ctx, &Constant{Value: types.NewDatum("你好world"), RetType: tp}, tp)
|
|
res, err := f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetString(), Equals, "你好wor")
|
|
|
|
// cast(str as char(N)), N > len([]rune(str)).
|
|
// cast("a" as char(5))
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("a"), RetType: types.NewFieldType(mysql.TypeString)}, tp)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(len(res.GetString()), Equals, 1)
|
|
c.Assert(res.GetString(), Equals, "a")
|
|
|
|
// cast(str as binary(N)), N < len(str).
|
|
// cast("你好world" as binary(5))
|
|
str := "你好world"
|
|
tp.Flag |= mysql.BinaryFlag
|
|
tp.Charset = charset.CharsetBin
|
|
tp.Collate = charset.CollationBin
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum(str), RetType: types.NewFieldType(mysql.TypeString)}, tp)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetString(), Equals, str[:5])
|
|
|
|
// cast(str as binary(N)), N > len([]byte(str)).
|
|
// cast("a" as binary(5))
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("a"), RetType: types.NewFieldType(mysql.TypeString)}, tp)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(len(res.GetString()), Equals, 5)
|
|
c.Assert(res.GetString(), Equals, string([]byte{'a', 0x00, 0x00, 0x00, 0x00}))
|
|
|
|
// cast(str as binary(N)), N > len([]byte(str)).
|
|
// cast("a" as binary(4294967295))
|
|
tp.Flen = 4294967295
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("a"), RetType: types.NewFieldType(mysql.TypeString)}, tp)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.IsNull(), IsTrue)
|
|
warnings := sc.GetWarnings()
|
|
lastWarn := warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(errWarnAllowedPacketOverflowed, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
origSc := sc
|
|
oldInSelectStmt := sc.InSelectStmt
|
|
sc.InSelectStmt = true
|
|
defer func() {
|
|
sc.InSelectStmt = oldInSelectStmt
|
|
}()
|
|
sc.OverflowAsWarning = true
|
|
|
|
// cast('18446744073709551616' as unsigned);
|
|
tp1 := &types.FieldType{
|
|
Tp: mysql.TypeLonglong,
|
|
Flag: mysql.BinaryFlag,
|
|
Charset: charset.CharsetBin,
|
|
Collate: charset.CollationBin,
|
|
Flen: mysql.MaxIntWidth,
|
|
}
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("18446744073709551616"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetUint64() == math.MaxUint64, IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
originFlag := tp1.Flag
|
|
tp1.Flag |= mysql.UnsignedFlag
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("-1"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetUint64() == 18446744073709551615, IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrCastNegIntAsUnsigned, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
tp1.Flag = originFlag
|
|
|
|
previousWarnings := len(sc.GetWarnings())
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("-1"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetInt64() == -1, IsTrue)
|
|
c.Assert(len(sc.GetWarnings()) == previousWarnings, IsTrue)
|
|
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("-18446744073709551616"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
t := math.MinInt64
|
|
// 9223372036854775808
|
|
c.Assert(res.GetUint64() == uint64(t), IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// cast('125e342.83' as unsigned)
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("125e342.83"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetUint64() == 125, IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// cast('1e9223372036854775807' as unsigned)
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("1e9223372036854775807"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetUint64() == 1, IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// cast('18446744073709551616' as signed);
|
|
mask := ^mysql.UnsignedFlag
|
|
tp1.Flag &= uint(mask)
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("18446744073709551616"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Check(res.GetInt64(), Equals, int64(-1))
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// cast('18446744073709551614' as signed);
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("18446744073709551614"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Check(res.GetInt64(), Equals, int64(-2))
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrCastAsSignedOverflow, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// cast('125e342.83' as signed)
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("125e342.83"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetInt64() == 125, IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// cast('1e9223372036854775807' as signed)
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum("1e9223372036854775807"), RetType: types.NewFieldType(mysql.TypeString)}, tp1)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.GetInt64() == 1, IsTrue)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrTruncatedWrongVal, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
|
|
// create table t1(s1 time);
|
|
// insert into t1 values('11:11:11');
|
|
// select cast(s1 as decimal(7, 2)) from t1;
|
|
ft := &types.FieldType{
|
|
Tp: mysql.TypeNewDecimal,
|
|
Flag: mysql.BinaryFlag | mysql.UnsignedFlag,
|
|
Charset: charset.CharsetBin,
|
|
Collate: charset.CollationBin,
|
|
Flen: 7,
|
|
Decimal: 2,
|
|
}
|
|
f = BuildCastFunction(ctx, &Constant{Value: timeDatum, RetType: types.NewFieldType(mysql.TypeDatetime)}, ft)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
resDecimal := new(types.MyDecimal)
|
|
resDecimal.FromString([]byte("99999.99"))
|
|
c.Assert(res.GetMysqlDecimal().Compare(resDecimal), Equals, 0)
|
|
|
|
warnings = sc.GetWarnings()
|
|
lastWarn = warnings[len(warnings)-1]
|
|
c.Assert(terror.ErrorEqual(types.ErrOverflow, lastWarn.Err), IsTrue, Commentf("err %v", lastWarn.Err))
|
|
sc = origSc
|
|
|
|
// create table tt(a bigint unsigned);
|
|
// insert into tt values(18446744073709551615);
|
|
// select cast(a as decimal(65, 0)) from tt;
|
|
ft = &types.FieldType{
|
|
Tp: mysql.TypeNewDecimal,
|
|
Flag: mysql.BinaryFlag,
|
|
Charset: charset.CharsetBin,
|
|
Collate: charset.CollationBin,
|
|
Flen: 65,
|
|
Decimal: 0,
|
|
}
|
|
rt := types.NewFieldType(mysql.TypeLonglong)
|
|
rt.Flag = mysql.BinaryFlag | mysql.UnsignedFlag
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewUintDatum(18446744073709551615), RetType: rt}, ft)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
u, err := res.GetMysqlDecimal().ToUint()
|
|
c.Assert(err, IsNil)
|
|
c.Assert(u == 18446744073709551615, IsTrue)
|
|
|
|
// cast(bad_string as decimal)
|
|
for _, s := range []string{"hello", ""} {
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum(s), RetType: types.NewFieldType(mysql.TypeDecimal)}, tp)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
}
|
|
|
|
// cast(1234 as char(0))
|
|
tp.Flen = 0
|
|
tp.Charset = charset.CharsetUTF8
|
|
f = BuildCastFunction(ctx, &Constant{Value: types.NewDatum(1234), RetType: types.NewFieldType(mysql.TypeString)}, tp)
|
|
res, err = f.Eval(chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(len(res.GetString()), Equals, 0)
|
|
c.Assert(res.GetString(), Equals, "")
|
|
}
|
|
|
|
var (
|
|
year, month, day = time.Now().In(time.UTC).Date()
|
|
curDateInt = int64(year*10000 + int(month)*100 + day)
|
|
curTimeInt = int64(curDateInt*1000000 + 125959)
|
|
curTimeWithFspReal = float64(curTimeInt) + 0.555
|
|
curTimeString = fmt.Sprintf("%4d-%02d-%02d 12:59:59", year, int(month), day)
|
|
curTimeWithFspString = fmt.Sprintf("%4d-%02d-%02d 12:59:59.555000", year, int(month), day)
|
|
tm = types.NewTime(types.FromDate(year, int(month), day, 12, 59, 59, 0), mysql.TypeDatetime, types.DefaultFsp)
|
|
tmWithFsp = types.NewTime(types.FromDate(year, int(month), day, 12, 59, 59, 555000), mysql.TypeDatetime, types.MaxFsp)
|
|
// timeDatum indicates datetime "curYear-curMonth-curDay 12:59:59".
|
|
timeDatum = types.NewDatum(tm)
|
|
// timeWithFspDatum indicates datetime "curYear-curMonth-curDay 12:59:59.555000".
|
|
timeWithFspDatum = types.NewDatum(tmWithFsp)
|
|
duration = types.Duration{
|
|
Duration: time.Duration(12*time.Hour + 59*time.Minute + 59*time.Second),
|
|
Fsp: types.DefaultFsp}
|
|
// durationDatum indicates duration "12:59:59".
|
|
durationDatum = types.NewDatum(duration)
|
|
durationWithFsp = types.Duration{
|
|
Duration: time.Duration(12*time.Hour + 59*time.Minute + 59*time.Second + 555*time.Millisecond),
|
|
Fsp: 3}
|
|
// durationWithFspDatum indicates duration "12:59:59.555"
|
|
durationWithFspDatum = types.NewDatum(durationWithFsp)
|
|
dt = types.NewTime(types.FromDate(year, int(month), day, 0, 0, 0, 0), mysql.TypeDate, types.DefaultFsp)
|
|
|
|
// jsonInt indicates json(3)
|
|
jsonInt = types.NewDatum(json.CreateBinary(int64(3)))
|
|
|
|
// jsonTime indicates "CURRENT_DAY 12:59:59"
|
|
jsonTime = types.NewDatum(json.CreateBinary(tm.String()))
|
|
|
|
// jsonDuration indicates
|
|
jsonDuration = types.NewDatum(json.CreateBinary(duration.String()))
|
|
)
|
|
|
|
func (s *testEvaluatorSuite) TestCastFuncSig(c *C) {
|
|
ctx, sc := s.ctx, s.ctx.GetSessionVars().StmtCtx
|
|
originIgnoreTruncate := sc.IgnoreTruncate
|
|
originTZ := sc.TimeZone
|
|
sc.IgnoreTruncate = true
|
|
sc.TimeZone = time.UTC
|
|
defer func() {
|
|
sc.IgnoreTruncate = originIgnoreTruncate
|
|
sc.TimeZone = originTZ
|
|
}()
|
|
var sig builtinFunc
|
|
|
|
durationColumn := &Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0}
|
|
durationColumn.RetType.Decimal = int(types.DefaultFsp)
|
|
// Test cast as Decimal.
|
|
castToDecCases := []struct {
|
|
before *Column
|
|
after *types.MyDecimal
|
|
row chunk.MutRow
|
|
}{
|
|
// cast int as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
types.NewDecFromInt(1),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(1)}),
|
|
},
|
|
// cast string as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
types.NewDecFromInt(1),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("1")}),
|
|
},
|
|
// cast real as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
types.NewDecFromInt(1),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(1)}),
|
|
},
|
|
// cast Time as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
types.NewDecFromInt(curTimeInt),
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast Duration as decimal.
|
|
{
|
|
durationColumn,
|
|
types.NewDecFromInt(125959),
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
}
|
|
for i, t := range castToDecCases {
|
|
args := []Expression{t.before}
|
|
b, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
decFunc := newBaseBuiltinCastFunc(b, false)
|
|
decFunc.tp = types.NewFieldType(mysql.TypeNewDecimal)
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastIntAsDecimalSig{decFunc}
|
|
case 1:
|
|
sig = &builtinCastStringAsDecimalSig{decFunc}
|
|
case 2:
|
|
sig = &builtinCastRealAsDecimalSig{decFunc}
|
|
case 3:
|
|
sig = &builtinCastTimeAsDecimalSig{decFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsDecimalSig{decFunc}
|
|
case 5:
|
|
sig = &builtinCastDecimalAsDecimalSig{decFunc}
|
|
}
|
|
res, isNull, err := sig.evalDecimal(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.Compare(t.after), Equals, 0)
|
|
}
|
|
|
|
durationColumn.RetType.Decimal = 1
|
|
castToDecCases2 := []struct {
|
|
before *Column
|
|
flen int
|
|
decimal int
|
|
after *types.MyDecimal
|
|
row chunk.MutRow
|
|
}{
|
|
// cast int as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
7,
|
|
3,
|
|
types.NewDecFromStringForTest("1234.000"),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(1234)}),
|
|
},
|
|
// cast string as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
7,
|
|
3,
|
|
types.NewDecFromStringForTest("1234.000"),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("1234")}),
|
|
},
|
|
// cast real as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
8,
|
|
4,
|
|
types.NewDecFromStringForTest("1234.1230"),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(1234.123)}),
|
|
},
|
|
// cast Time as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
15,
|
|
1,
|
|
types.NewDecFromStringForTest(strconv.FormatInt(curTimeInt, 10) + ".0"),
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast Duration as decimal.
|
|
{
|
|
durationColumn,
|
|
7,
|
|
1,
|
|
types.NewDecFromStringForTest("125959.0"),
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast decimal as decimal.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
7,
|
|
3,
|
|
types.NewDecFromStringForTest("1234.000"),
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromStringForTest("1234"))}),
|
|
},
|
|
}
|
|
|
|
for i, t := range castToDecCases2 {
|
|
args := []Expression{t.before}
|
|
tp := types.NewFieldType(mysql.TypeNewDecimal)
|
|
tp.Flen, tp.Decimal = t.flen, t.decimal
|
|
b, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
decFunc := newBaseBuiltinCastFunc(b, false)
|
|
decFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastIntAsDecimalSig{decFunc}
|
|
case 1:
|
|
sig = &builtinCastStringAsDecimalSig{decFunc}
|
|
case 2:
|
|
sig = &builtinCastRealAsDecimalSig{decFunc}
|
|
case 3:
|
|
sig = &builtinCastTimeAsDecimalSig{decFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsDecimalSig{decFunc}
|
|
case 5:
|
|
sig = &builtinCastDecimalAsDecimalSig{decFunc}
|
|
}
|
|
res, isNull, err := sig.evalDecimal(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.ToString(), DeepEquals, t.after.ToString())
|
|
}
|
|
|
|
durationColumn.RetType.Decimal = 0
|
|
// Test cast as int.
|
|
castToIntCases := []struct {
|
|
before *Column
|
|
after int64
|
|
row chunk.MutRow
|
|
}{
|
|
// cast string as int.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
1,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("1")}),
|
|
},
|
|
// cast decimal as int.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
1,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromInt(1))}),
|
|
},
|
|
// cast real as int.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
1,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(1)}),
|
|
},
|
|
// cast Time as int.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
curTimeInt,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast Duration as int.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
125959,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast JSON as int.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeJSON), Index: 0},
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{jsonInt}),
|
|
},
|
|
}
|
|
for i, t := range castToIntCases {
|
|
args := []Expression{t.before}
|
|
b, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
intFunc := newBaseBuiltinCastFunc(b, false)
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastStringAsIntSig{intFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsIntSig{intFunc}
|
|
case 2:
|
|
sig = &builtinCastRealAsIntSig{intFunc}
|
|
case 3:
|
|
sig = &builtinCastTimeAsIntSig{intFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsIntSig{intFunc}
|
|
case 5:
|
|
sig = &builtinCastJSONAsIntSig{intFunc}
|
|
}
|
|
res, isNull, err := sig.evalInt(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res, Equals, t.after)
|
|
}
|
|
|
|
// Test cast as real.
|
|
castToRealCases := []struct {
|
|
before *Column
|
|
after float64
|
|
row chunk.MutRow
|
|
}{
|
|
// cast string as real.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
1.1,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("1.1")}),
|
|
},
|
|
// cast decimal as real.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
1.1,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromFloatForTest(1.1))}),
|
|
},
|
|
// cast int as real.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
1,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(1)}),
|
|
},
|
|
// cast Time as real.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
float64(curTimeInt),
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast Duration as real.
|
|
{
|
|
durationColumn,
|
|
125959,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast JSON as real.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeJSON), Index: 0},
|
|
3.0,
|
|
chunk.MutRowFromDatums([]types.Datum{jsonInt}),
|
|
},
|
|
}
|
|
for i, t := range castToRealCases {
|
|
args := []Expression{t.before}
|
|
b, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
realFunc := newBaseBuiltinCastFunc(b, false)
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastStringAsRealSig{realFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsRealSig{realFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsRealSig{realFunc}
|
|
case 3:
|
|
sig = &builtinCastTimeAsRealSig{realFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsRealSig{realFunc}
|
|
case 5:
|
|
sig = &builtinCastJSONAsRealSig{realFunc}
|
|
}
|
|
res, isNull, err := sig.evalReal(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res, Equals, t.after)
|
|
}
|
|
|
|
// Test cast as string.
|
|
castToStringCases := []struct {
|
|
before *Column
|
|
after string
|
|
row chunk.MutRow
|
|
}{
|
|
// cast real as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
"1",
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(1)}),
|
|
},
|
|
// cast decimal as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
"1",
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromInt(1))}),
|
|
},
|
|
// cast int as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
"1",
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(1)}),
|
|
},
|
|
// cast time as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
curTimeString,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast duration as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
"12:59:59",
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast JSON as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeJSON), Index: 0},
|
|
"3",
|
|
chunk.MutRowFromDatums([]types.Datum{jsonInt}),
|
|
},
|
|
// cast string as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
"1234",
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("1234")}),
|
|
},
|
|
}
|
|
for i, t := range castToStringCases {
|
|
tp := types.NewFieldType(mysql.TypeVarString)
|
|
tp.Charset = charset.CharsetBin
|
|
args := []Expression{t.before}
|
|
stringFunc, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
stringFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastRealAsStringSig{stringFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsStringSig{stringFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsStringSig{stringFunc}
|
|
case 3:
|
|
sig = &builtinCastTimeAsStringSig{stringFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsStringSig{stringFunc}
|
|
case 5:
|
|
sig = &builtinCastJSONAsStringSig{stringFunc}
|
|
case 6:
|
|
sig = &builtinCastStringAsStringSig{stringFunc}
|
|
}
|
|
res, isNull, err := sig.evalString(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res, Equals, t.after)
|
|
}
|
|
|
|
// Test cast as string.
|
|
castToStringCases2 := []struct {
|
|
before *Column
|
|
after string
|
|
flen int
|
|
row chunk.MutRow
|
|
}{
|
|
// cast real as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
"123",
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(1234.123)}),
|
|
},
|
|
// cast decimal as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
"123",
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromStringForTest("1234.123"))}),
|
|
},
|
|
// cast int as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
"123",
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(1234)}),
|
|
},
|
|
// cast time as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
curTimeString[:3],
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast duration as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
"12:",
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast string as string.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
"你好w",
|
|
3,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("你好world")}),
|
|
},
|
|
}
|
|
for i, t := range castToStringCases2 {
|
|
args := []Expression{t.before}
|
|
tp := types.NewFieldType(mysql.TypeVarString)
|
|
tp.Flen, tp.Charset = t.flen, charset.CharsetBin
|
|
stringFunc, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
stringFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastRealAsStringSig{stringFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsStringSig{stringFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsStringSig{stringFunc}
|
|
case 3:
|
|
sig = &builtinCastTimeAsStringSig{stringFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsStringSig{stringFunc}
|
|
case 5:
|
|
stringFunc.tp.Charset = charset.CharsetUTF8
|
|
sig = &builtinCastStringAsStringSig{stringFunc}
|
|
}
|
|
res, isNull, err := sig.evalString(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res, Equals, t.after)
|
|
}
|
|
|
|
castToTimeCases := []struct {
|
|
before *Column
|
|
after types.Time
|
|
row chunk.MutRow
|
|
}{
|
|
// cast real as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(float64(curTimeInt))}),
|
|
},
|
|
// cast decimal as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromInt(curTimeInt))}),
|
|
},
|
|
// cast int as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(curTimeInt)}),
|
|
},
|
|
// cast string as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum(curTimeString)}),
|
|
},
|
|
// cast Duration as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast JSON as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeJSON), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{jsonTime}),
|
|
},
|
|
// cast Time as Time.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
tm,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
}
|
|
for i, t := range castToTimeCases {
|
|
args := []Expression{t.before}
|
|
tp := types.NewFieldType(mysql.TypeDatetime)
|
|
tp.Decimal = int(types.DefaultFsp)
|
|
timeFunc, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
timeFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastRealAsTimeSig{timeFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsTimeSig{timeFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsTimeSig{timeFunc}
|
|
case 3:
|
|
sig = &builtinCastStringAsTimeSig{timeFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsTimeSig{timeFunc}
|
|
case 5:
|
|
sig = &builtinCastJSONAsTimeSig{timeFunc}
|
|
case 6:
|
|
sig = &builtinCastTimeAsTimeSig{timeFunc}
|
|
}
|
|
res, isNull, err := sig.evalTime(t.row.ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(res.String(), Equals, t.after.String())
|
|
}
|
|
|
|
castToTimeCases2 := []struct {
|
|
before *Column
|
|
after types.Time
|
|
fsp int8
|
|
tp byte
|
|
row chunk.MutRow
|
|
}{
|
|
// cast real as Time(0).
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
dt,
|
|
types.DefaultFsp,
|
|
mysql.TypeDate,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(float64(curTimeInt))}),
|
|
},
|
|
// cast decimal as Date.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
dt,
|
|
types.DefaultFsp,
|
|
mysql.TypeDate,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromInt(curTimeInt))}),
|
|
},
|
|
// cast int as Datetime(6).
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
tm,
|
|
types.MaxFsp,
|
|
mysql.TypeDatetime,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(curTimeInt)}),
|
|
},
|
|
// cast string as Datetime(6).
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
tm,
|
|
types.MaxFsp,
|
|
mysql.TypeDatetime,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum(curTimeString)}),
|
|
},
|
|
// cast Duration as Date.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
dt,
|
|
types.DefaultFsp,
|
|
mysql.TypeDate,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
// cast Time as Date.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
dt,
|
|
types.DefaultFsp,
|
|
mysql.TypeDate,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
}
|
|
for i, t := range castToTimeCases2 {
|
|
args := []Expression{t.before}
|
|
tp := types.NewFieldType(t.tp)
|
|
tp.Decimal = int(t.fsp)
|
|
timeFunc, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
timeFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastRealAsTimeSig{timeFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsTimeSig{timeFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsTimeSig{timeFunc}
|
|
case 3:
|
|
sig = &builtinCastStringAsTimeSig{timeFunc}
|
|
case 4:
|
|
sig = &builtinCastDurationAsTimeSig{timeFunc}
|
|
case 5:
|
|
sig = &builtinCastTimeAsTimeSig{timeFunc}
|
|
}
|
|
res, isNull, err := sig.evalTime(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
resAfter := t.after.String()
|
|
if t.fsp > 0 {
|
|
resAfter += "."
|
|
for i := 0; i < int(t.fsp); i++ {
|
|
resAfter += "0"
|
|
}
|
|
}
|
|
c.Assert(res.String(), Equals, resAfter)
|
|
}
|
|
|
|
castToDurationCases := []struct {
|
|
before *Column
|
|
after types.Duration
|
|
row chunk.MutRow
|
|
}{
|
|
// cast real as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(125959)}),
|
|
},
|
|
// cast decimal as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromInt(125959))}),
|
|
},
|
|
// cast int as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(125959)}),
|
|
},
|
|
// cast string as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("12:59:59")}),
|
|
},
|
|
// cast Time as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
},
|
|
// cast JSON as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeJSON), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{jsonDuration}),
|
|
},
|
|
// cast Duration as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
},
|
|
}
|
|
for i, t := range castToDurationCases {
|
|
args := []Expression{t.before}
|
|
tp := types.NewFieldType(mysql.TypeDuration)
|
|
tp.Decimal = int(types.DefaultFsp)
|
|
durationFunc, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
durationFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastRealAsDurationSig{durationFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsDurationSig{durationFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsDurationSig{durationFunc}
|
|
case 3:
|
|
sig = &builtinCastStringAsDurationSig{durationFunc}
|
|
case 4:
|
|
sig = &builtinCastTimeAsDurationSig{durationFunc}
|
|
case 5:
|
|
sig = &builtinCastJSONAsDurationSig{durationFunc}
|
|
case 6:
|
|
sig = &builtinCastDurationAsDurationSig{durationFunc}
|
|
}
|
|
res, isNull, err := sig.evalDuration(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.String(), Equals, t.after.String())
|
|
}
|
|
|
|
castToDurationCases2 := []struct {
|
|
before *Column
|
|
after types.Duration
|
|
row chunk.MutRow
|
|
fsp int
|
|
}{
|
|
// cast real as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewFloat64Datum(125959)}),
|
|
1,
|
|
},
|
|
// cast decimal as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromInt(125959))}),
|
|
2,
|
|
},
|
|
// cast int as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLonglong), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewIntDatum(125959)}),
|
|
3,
|
|
},
|
|
// cast string as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("12:59:59")}),
|
|
4,
|
|
},
|
|
// cast Time as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
5,
|
|
},
|
|
// cast Duration as Duration.
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0},
|
|
duration,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
6,
|
|
},
|
|
}
|
|
for i, t := range castToDurationCases2 {
|
|
args := []Expression{t.before}
|
|
tp := types.NewFieldType(mysql.TypeDuration)
|
|
tp.Decimal = t.fsp
|
|
durationFunc, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
durationFunc.tp = tp
|
|
switch i {
|
|
case 0:
|
|
sig = &builtinCastRealAsDurationSig{durationFunc}
|
|
case 1:
|
|
sig = &builtinCastDecimalAsDurationSig{durationFunc}
|
|
case 2:
|
|
sig = &builtinCastIntAsDurationSig{durationFunc}
|
|
case 3:
|
|
sig = &builtinCastStringAsDurationSig{durationFunc}
|
|
case 4:
|
|
sig = &builtinCastTimeAsDurationSig{durationFunc}
|
|
case 5:
|
|
sig = &builtinCastDurationAsDurationSig{durationFunc}
|
|
}
|
|
res, isNull, err := sig.evalDuration(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
resAfter := t.after.String()
|
|
if t.fsp > 0 {
|
|
resAfter += "."
|
|
for j := 0; j < t.fsp; j++ {
|
|
resAfter += "0"
|
|
}
|
|
}
|
|
c.Assert(res.String(), Equals, resAfter)
|
|
}
|
|
|
|
// null case
|
|
args := []Expression{&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0}}
|
|
row := chunk.MutRowFromDatums([]types.Datum{types.NewDatum(nil)})
|
|
bf, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
bf.tp = types.NewFieldType(mysql.TypeVarString)
|
|
sig = &builtinCastRealAsStringSig{bf}
|
|
sRes, isNull, err := sig.evalString(row.ToRow())
|
|
c.Assert(sRes, Equals, "")
|
|
c.Assert(isNull, Equals, true)
|
|
c.Assert(err, IsNil)
|
|
|
|
// test hybridType case.
|
|
args = []Expression{&Constant{Value: types.NewDatum(types.Enum{Name: "a", Value: 0}), RetType: types.NewFieldType(mysql.TypeEnum)}}
|
|
b, err := newBaseBuiltinFunc(ctx, "", args)
|
|
c.Assert(err, IsNil)
|
|
sig = &builtinCastStringAsIntSig{newBaseBuiltinCastFunc(b, false)}
|
|
iRes, isNull, err := sig.evalInt(chunk.Row{})
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(iRes, Equals, int64(0))
|
|
}
|
|
|
|
func (s *testEvaluatorSuite) TestCastJSONAsDecimalSig(c *C) {
|
|
ctx, sc := s.ctx, s.ctx.GetSessionVars().StmtCtx
|
|
originIgnoreTruncate := sc.IgnoreTruncate
|
|
sc.IgnoreTruncate = true
|
|
defer func() {
|
|
sc.IgnoreTruncate = originIgnoreTruncate
|
|
}()
|
|
|
|
col := &Column{RetType: types.NewFieldType(mysql.TypeJSON), Index: 0}
|
|
b, err := newBaseBuiltinFunc(ctx, "", []Expression{col})
|
|
c.Assert(err, IsNil)
|
|
decFunc := newBaseBuiltinCastFunc(b, false)
|
|
decFunc.tp = types.NewFieldType(mysql.TypeNewDecimal)
|
|
decFunc.tp.Flen = 60
|
|
decFunc.tp.Decimal = 2
|
|
sig := &builtinCastJSONAsDecimalSig{decFunc}
|
|
|
|
var tests = []struct {
|
|
In string
|
|
Out *types.MyDecimal
|
|
}{
|
|
{`{}`, types.NewDecFromStringForTest("0")},
|
|
{`[]`, types.NewDecFromStringForTest("0")},
|
|
{`3`, types.NewDecFromStringForTest("3")},
|
|
{`-3`, types.NewDecFromStringForTest("-3")},
|
|
{`4.5`, types.NewDecFromStringForTest("4.5")},
|
|
{`"1234"`, types.NewDecFromStringForTest("1234")},
|
|
// test truncate
|
|
{`"1234.1234"`, types.NewDecFromStringForTest("1234.12")},
|
|
{`"1234.4567"`, types.NewDecFromStringForTest("1234.46")},
|
|
// test big decimal
|
|
{`"1234567890123456789012345678901234567890123456789012345"`, types.NewDecFromStringForTest("1234567890123456789012345678901234567890123456789012345")},
|
|
}
|
|
for _, tt := range tests {
|
|
j, err := json.ParseBinaryFromString(tt.In)
|
|
c.Assert(err, IsNil)
|
|
row := chunk.MutRowFromDatums([]types.Datum{types.NewDatum(j)})
|
|
res, isNull, err := sig.evalDecimal(row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.Compare(tt.Out), Equals, 0)
|
|
}
|
|
}
|
|
|
|
// TestWrapWithCastAsTypesClasses tests WrapWithCastAsInt/Real/String/Decimal.
|
|
func (s *testEvaluatorSuite) TestWrapWithCastAsTypesClasses(c *C) {
|
|
ctx := s.ctx
|
|
|
|
durationColumn0 := &Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0}
|
|
durationColumn0.RetType.Decimal = int(types.DefaultFsp)
|
|
durationColumn3 := &Column{RetType: types.NewFieldType(mysql.TypeDuration), Index: 0}
|
|
durationColumn3.RetType.Decimal = 3
|
|
cases := []struct {
|
|
expr Expression
|
|
row chunk.MutRow
|
|
intRes int64
|
|
realRes float64
|
|
decRes *types.MyDecimal
|
|
stringRes string
|
|
}{
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeLong), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDatum(123)}),
|
|
123, 123, types.NewDecFromInt(123), "123",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDatum(123.555)}),
|
|
124, 123.555, types.NewDecFromFloatForTest(123.555), "123.555",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDouble), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDatum(123.123)}),
|
|
123, 123.123, types.NewDecFromFloatForTest(123.123), "123.123",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromStringForTest("123.123"))}),
|
|
123, 123.123, types.NewDecFromFloatForTest(123.123), "123.123",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeNewDecimal), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDecimalDatum(types.NewDecFromStringForTest("123.555"))}),
|
|
124, 123.555, types.NewDecFromFloatForTest(123.555), "123.555",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeVarString), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("123.123")}),
|
|
123, 123.123, types.NewDecFromStringForTest("123.123"), "123.123",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{timeDatum}),
|
|
curTimeInt, float64(curTimeInt), types.NewDecFromInt(curTimeInt), curTimeString,
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeDatetime), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{timeWithFspDatum}),
|
|
int64(curDateInt*1000000 + 130000), curTimeWithFspReal, types.NewDecFromFloatForTest(curTimeWithFspReal), curTimeWithFspString,
|
|
},
|
|
{
|
|
durationColumn0,
|
|
chunk.MutRowFromDatums([]types.Datum{durationDatum}),
|
|
125959, 125959, types.NewDecFromFloatForTest(125959), "12:59:59",
|
|
},
|
|
{
|
|
durationColumn3,
|
|
chunk.MutRowFromDatums([]types.Datum{durationWithFspDatum}),
|
|
130000, 125959.555, types.NewDecFromFloatForTest(125959.555), "12:59:59.555",
|
|
},
|
|
{
|
|
&Column{RetType: types.NewFieldType(mysql.TypeEnum), Index: 0},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDatum(types.Enum{Name: "a", Value: 123})}),
|
|
123, 123, types.NewDecFromStringForTest("123"), "a",
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeVarString), Value: types.NewBinaryLiteralDatum(types.NewBinaryLiteralFromUint(0x61, -1))},
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewDatum(nil)}),
|
|
97, 97, types.NewDecFromInt(0x61), "a",
|
|
},
|
|
}
|
|
for i, t := range cases {
|
|
// Test wrapping with CastAsInt.
|
|
intExpr := WrapWithCastAsInt(ctx, t.expr)
|
|
c.Assert(intExpr.GetType().EvalType(), Equals, types.ETInt)
|
|
intRes, isNull, err := intExpr.EvalInt(ctx, t.row.ToRow())
|
|
c.Assert(err, IsNil, Commentf("cast[%v]: %#v", i, t))
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(intRes, Equals, t.intRes)
|
|
|
|
// Test wrapping with CastAsReal.
|
|
realExpr := WrapWithCastAsReal(ctx, t.expr)
|
|
c.Assert(realExpr.GetType().EvalType(), Equals, types.ETReal)
|
|
realRes, isNull, err := realExpr.EvalReal(ctx, t.row.ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(realRes, Equals, t.realRes, Commentf("cast[%v]: %#v", i, t))
|
|
|
|
// Test wrapping with CastAsDecimal.
|
|
decExpr := WrapWithCastAsDecimal(ctx, t.expr)
|
|
c.Assert(decExpr.GetType().EvalType(), Equals, types.ETDecimal)
|
|
decRes, isNull, err := decExpr.EvalDecimal(ctx, t.row.ToRow())
|
|
c.Assert(err, IsNil, Commentf("case[%v]: %#v\n", i, t))
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(decRes.Compare(t.decRes), Equals, 0, Commentf("case[%v]: %#v\n", i, t))
|
|
|
|
// Test wrapping with CastAsString.
|
|
strExpr := WrapWithCastAsString(ctx, t.expr)
|
|
c.Assert(strExpr.GetType().EvalType().IsStringKind(), IsTrue)
|
|
strRes, isNull, err := strExpr.EvalString(ctx, t.row.ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(strRes, Equals, t.stringRes)
|
|
}
|
|
|
|
unsignedIntExpr := &Column{RetType: &types.FieldType{Tp: mysql.TypeLonglong, Flag: mysql.UnsignedFlag, Flen: mysql.MaxIntWidth, Decimal: 0}, Index: 0}
|
|
|
|
// test cast unsigned int as string.
|
|
strExpr := WrapWithCastAsString(ctx, unsignedIntExpr)
|
|
c.Assert(strExpr.GetType().EvalType().IsStringKind(), IsTrue)
|
|
strRes, isNull, err := strExpr.EvalString(ctx, chunk.MutRowFromDatums([]types.Datum{types.NewUintDatum(math.MaxUint64)}).ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(strRes, Equals, strconv.FormatUint(math.MaxUint64, 10))
|
|
c.Assert(isNull, Equals, false)
|
|
|
|
strRes, isNull, err = strExpr.EvalString(ctx, chunk.MutRowFromDatums([]types.Datum{types.NewUintDatum(1234)}).ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(strRes, Equals, strconv.FormatUint(uint64(1234), 10))
|
|
|
|
// test cast unsigned int as decimal.
|
|
decExpr := WrapWithCastAsDecimal(ctx, unsignedIntExpr)
|
|
c.Assert(decExpr.GetType().EvalType(), Equals, types.ETDecimal)
|
|
decRes, isNull, err := decExpr.EvalDecimal(ctx, chunk.MutRowFromDatums([]types.Datum{types.NewUintDatum(uint64(1234))}).ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(decRes.Compare(types.NewDecFromUint(uint64(1234))), Equals, 0)
|
|
|
|
// test cast unsigned int as Time.
|
|
timeExpr := WrapWithCastAsTime(ctx, unsignedIntExpr, types.NewFieldType(mysql.TypeDatetime))
|
|
c.Assert(timeExpr.GetType().Tp, Equals, mysql.TypeDatetime)
|
|
timeRes, isNull, err := timeExpr.EvalTime(ctx, chunk.MutRowFromDatums([]types.Datum{types.NewUintDatum(uint64(curTimeInt))}).ToRow())
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(timeRes.Compare(tm), Equals, 0)
|
|
}
|
|
|
|
func (s *testEvaluatorSuite) TestWrapWithCastAsTime(c *C) {
|
|
sc := s.ctx.GetSessionVars().StmtCtx
|
|
save := sc.TimeZone
|
|
sc.TimeZone = time.UTC
|
|
defer func() {
|
|
sc.TimeZone = save
|
|
}()
|
|
cases := []struct {
|
|
expr Expression
|
|
tp *types.FieldType
|
|
res types.Time
|
|
}{
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeLong), Value: types.NewIntDatum(curTimeInt)},
|
|
types.NewFieldType(mysql.TypeDate),
|
|
dt,
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeDouble), Value: types.NewFloat64Datum(float64(curTimeInt))},
|
|
types.NewFieldType(mysql.TypeDatetime),
|
|
tm,
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeNewDecimal), Value: types.NewDecimalDatum(types.NewDecFromInt(curTimeInt))},
|
|
types.NewFieldType(mysql.TypeDate),
|
|
dt,
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeVarString), Value: types.NewStringDatum(curTimeString)},
|
|
types.NewFieldType(mysql.TypeDatetime),
|
|
tm,
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeDatetime), Value: timeDatum},
|
|
types.NewFieldType(mysql.TypeDate),
|
|
dt,
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeDuration), Value: durationDatum},
|
|
types.NewFieldType(mysql.TypeDatetime),
|
|
tm,
|
|
},
|
|
}
|
|
for d, t := range cases {
|
|
expr := WrapWithCastAsTime(s.ctx, t.expr, t.tp)
|
|
res, isNull, err := expr.EvalTime(s.ctx, chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(res.Type(), Equals, t.tp.Tp)
|
|
c.Assert(res.Compare(t.res), Equals, 0, Commentf("case %d res = %s, expect = %s", d, res, t.res))
|
|
}
|
|
}
|
|
|
|
func (s *testEvaluatorSuite) TestWrapWithCastAsDuration(c *C) {
|
|
cases := []struct {
|
|
expr Expression
|
|
}{
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeLong), Value: types.NewIntDatum(125959)},
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeDouble), Value: types.NewFloat64Datum(125959)},
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeNewDecimal), Value: types.NewDecimalDatum(types.NewDecFromInt(125959))},
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeVarString), Value: types.NewStringDatum("125959")},
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeDatetime), Value: timeDatum},
|
|
},
|
|
{
|
|
&Constant{RetType: types.NewFieldType(mysql.TypeDuration), Value: durationDatum},
|
|
},
|
|
}
|
|
for _, t := range cases {
|
|
expr := WrapWithCastAsDuration(s.ctx, t.expr)
|
|
res, isNull, err := expr.EvalDuration(s.ctx, chunk.Row{})
|
|
c.Assert(err, IsNil)
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(res.Compare(duration), Equals, 0)
|
|
}
|
|
}
|
|
|
|
func (s *testEvaluatorSuite) TestWrapWithCastAsJSON(c *C) {
|
|
input := &Column{RetType: &types.FieldType{Tp: mysql.TypeJSON}}
|
|
expr := WrapWithCastAsJSON(s.ctx, input)
|
|
|
|
output, ok := expr.(*Column)
|
|
c.Assert(ok, IsTrue)
|
|
c.Assert(output, Equals, input)
|
|
}
|
|
|
|
func (s *testEvaluatorSuite) TestCastIntAsIntVec(c *C) {
|
|
cast, input, result := genCastIntAsInt()
|
|
c.Assert(cast.vecEvalInt(input, result), IsNil)
|
|
i64s := result.Int64s()
|
|
it := chunk.NewIterator4Chunk(input)
|
|
i := 0
|
|
for row := it.Begin(); row != it.End(); row = it.Next() {
|
|
v, _, err := cast.evalInt(row)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, Equals, i64s[i])
|
|
i++
|
|
}
|
|
|
|
cast.inUnion = true
|
|
cast.getRetTp().Flag |= mysql.UnsignedFlag
|
|
c.Assert(cast.vecEvalInt(input, result), IsNil)
|
|
i64s = result.Int64s()
|
|
it = chunk.NewIterator4Chunk(input)
|
|
i = 0
|
|
for row := it.Begin(); row != it.End(); row = it.Next() {
|
|
v, _, err := cast.evalInt(row)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, Equals, i64s[i])
|
|
i++
|
|
}
|
|
}
|
|
|
|
// for issue https://github.com/pingcap/tidb/issues/16825
|
|
func (s *testEvaluatorSuite) TestCastStringAsDecimalSigWithUnsignedFlagInUnion(c *C) {
|
|
col := &Column{RetType: types.NewFieldType(mysql.TypeString), Index: 0}
|
|
b, err := newBaseBuiltinFunc(mock.NewContext(), "", []Expression{col})
|
|
c.Assert(err, IsNil)
|
|
// set `inUnion` to `true`
|
|
decFunc := newBaseBuiltinCastFunc(b, true)
|
|
decFunc.tp = types.NewFieldType(mysql.TypeNewDecimal)
|
|
// set the `UnsignedFlag` bit
|
|
decFunc.tp.Flag |= mysql.UnsignedFlag
|
|
cast := &builtinCastStringAsDecimalSig{decFunc}
|
|
|
|
cases := []struct {
|
|
row chunk.MutRow
|
|
res *types.MyDecimal
|
|
}{
|
|
// if `inUnion` is `true`, the result of cast a positive decimal string to unsigned decimal should be normal
|
|
{
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("1")}),
|
|
types.NewDecFromInt(1),
|
|
},
|
|
// if `inUnion` is `true`, the result of cast a negative decimal string to unsigned decimal should be 0
|
|
{
|
|
chunk.MutRowFromDatums([]types.Datum{types.NewStringDatum("-1")}),
|
|
types.NewDecFromInt(0),
|
|
},
|
|
}
|
|
|
|
for _, t := range cases {
|
|
res, isNull, err := cast.evalDecimal(t.row.ToRow())
|
|
c.Assert(isNull, Equals, false)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(res.Compare(t.res), Equals, 0)
|
|
}
|
|
}
|
|
|