278 lines
6.6 KiB
Go
278 lines
6.6 KiB
Go
// Copyright 2015 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 builtin
|
|
|
|
import (
|
|
"strings"
|
|
"time"
|
|
|
|
. "github.com/pingcap/check"
|
|
"github.com/pingcap/tidb/mysql"
|
|
)
|
|
|
|
func (s *testBuiltinSuite) TestDate(c *C) {
|
|
tblDate := []struct {
|
|
Input interface{}
|
|
Expect interface{}
|
|
}{
|
|
{"2011-11-11", "2011-11-11"},
|
|
{nil, nil},
|
|
{"2011-11-11 10:10:10", "2011-11-11"},
|
|
}
|
|
|
|
for _, t := range tblDate {
|
|
v, err := builtinDate([]interface{}{t.Input}, nil)
|
|
c.Assert(err, IsNil)
|
|
switch x := v.(type) {
|
|
case nil:
|
|
c.Assert(t.Expect, IsNil)
|
|
case mysql.Time:
|
|
c.Assert(x.String(), Equals, t.Expect)
|
|
default:
|
|
c.Assert(x, DeepEquals, t.Expect)
|
|
}
|
|
}
|
|
|
|
// test year, month and day
|
|
tbl := []struct {
|
|
Input string
|
|
Year int64
|
|
Month int64
|
|
DayOfMonth int64
|
|
DayOfWeek int64
|
|
DayOfYear int64
|
|
WeekDay int64
|
|
Week int64
|
|
WeekOfYear int64
|
|
YearWeek int64
|
|
}{
|
|
{"2000-01-01", 2000, 1, 1, 7, 1, 5, 52, 52, 199952},
|
|
{"2011-11-11", 2011, 11, 11, 6, 315, 4, 45, 45, 201145},
|
|
}
|
|
|
|
for _, t := range tbl {
|
|
args := []interface{}{t.Input}
|
|
v, err := builtinYear(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Year)
|
|
|
|
v, err = builtinMonth(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Month)
|
|
|
|
v, err = builtinDayOfMonth(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.DayOfMonth)
|
|
|
|
v, err = builtinDayOfWeek(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.DayOfWeek)
|
|
|
|
v, err = builtinDayOfYear(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.DayOfYear)
|
|
|
|
v, err = builtinWeekDay(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.WeekDay)
|
|
|
|
v, err = builtinWeek(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Week)
|
|
|
|
v, err = builtinWeekOfYear(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.WeekOfYear)
|
|
|
|
v, err = builtinYearWeek(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.YearWeek)
|
|
}
|
|
|
|
// test nil
|
|
tblNil := []struct {
|
|
Input interface{}
|
|
Year interface{}
|
|
Month interface{}
|
|
DayOfMonth interface{}
|
|
DayOfWeek interface{}
|
|
DayOfYear interface{}
|
|
WeekDay interface{}
|
|
Week interface{}
|
|
WeekOfYear interface{}
|
|
YearWeek interface{}
|
|
}{
|
|
{nil, nil, nil, nil, nil, nil, nil, nil, nil, nil},
|
|
{"0000-00-00", int64(0), int64(0), int64(0), nil, nil, nil, nil, nil, nil},
|
|
}
|
|
|
|
for _, t := range tblNil {
|
|
args := []interface{}{t.Input}
|
|
v, err := builtinYear(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Year)
|
|
|
|
v, err = builtinMonth(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Month)
|
|
|
|
v, err = builtinDayOfMonth(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.DayOfMonth)
|
|
|
|
v, err = builtinDayOfWeek(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.DayOfWeek)
|
|
|
|
v, err = builtinDayOfYear(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.DayOfYear)
|
|
|
|
v, err = builtinWeekDay(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.WeekDay)
|
|
|
|
v, err = builtinWeek(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Week)
|
|
|
|
v, err = builtinWeekOfYear(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.WeekOfYear)
|
|
|
|
v, err = builtinYearWeek(args, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.YearWeek)
|
|
}
|
|
}
|
|
|
|
func (s *testBuiltinSuite) TestClock(c *C) {
|
|
// test hour, minute, second, micro second
|
|
|
|
tbl := []struct {
|
|
Input string
|
|
Hour int64
|
|
Minute int64
|
|
Second int64
|
|
MicroSecond int64
|
|
}{
|
|
{"10:10:10.123456", 10, 10, 10, 123456},
|
|
{"11:11:11.11", 11, 11, 11, 110000},
|
|
{"2010-10-10 11:11:11.11", 11, 11, 11, 110000},
|
|
}
|
|
|
|
for _, t := range tbl {
|
|
v, err := builtinHour([]interface{}{t.Input}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Hour)
|
|
|
|
v, err = builtinMinute([]interface{}{t.Input}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Minute)
|
|
|
|
v, err = builtinSecond([]interface{}{t.Input}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.Second)
|
|
|
|
v, err = builtinMicroSecond([]interface{}{t.Input}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, DeepEquals, t.MicroSecond)
|
|
}
|
|
|
|
// nil
|
|
v, err := builtinHour([]interface{}{nil}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, IsNil)
|
|
|
|
v, err = builtinMinute([]interface{}{nil}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, IsNil)
|
|
|
|
v, err = builtinSecond([]interface{}{nil}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, IsNil)
|
|
|
|
v, err = builtinMicroSecond([]interface{}{nil}, nil)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(v, IsNil)
|
|
|
|
// test error
|
|
errTbl := []string{
|
|
"2011-11-11T10:10:10.11",
|
|
}
|
|
|
|
for _, t := range errTbl {
|
|
_, err := builtinHour([]interface{}{t}, nil)
|
|
c.Assert(err, NotNil)
|
|
|
|
_, err = builtinMinute([]interface{}{t}, nil)
|
|
c.Assert(err, NotNil)
|
|
|
|
_, err = builtinSecond([]interface{}{t}, nil)
|
|
c.Assert(err, NotNil)
|
|
|
|
_, err = builtinMicroSecond([]interface{}{t}, nil)
|
|
c.Assert(err, NotNil)
|
|
}
|
|
}
|
|
|
|
func (s *testBuiltinSuite) TestNow(c *C) {
|
|
v, err := builtinNow(nil, nil)
|
|
c.Assert(err, IsNil)
|
|
t, ok := v.(mysql.Time)
|
|
c.Assert(ok, IsTrue)
|
|
// we canot use a constant value to check now, so here
|
|
// just to check whether has fractional seconds part.
|
|
c.Assert(strings.Contains(t.String(), "."), IsFalse)
|
|
|
|
v, err = builtinNow([]interface{}{6}, nil)
|
|
c.Assert(err, IsNil)
|
|
t, ok = v.(mysql.Time)
|
|
c.Assert(ok, IsTrue)
|
|
c.Assert(strings.Contains(t.String(), "."), IsTrue)
|
|
|
|
_, err = builtinNow([]interface{}{8}, nil)
|
|
c.Assert(err, NotNil)
|
|
|
|
_, err = builtinNow([]interface{}{-2}, nil)
|
|
c.Assert(err, NotNil)
|
|
}
|
|
|
|
func (s *testBuiltinSuite) TestSysDate(c *C) {
|
|
last := time.Now()
|
|
v, err := builtinSysDate(nil, nil)
|
|
c.Assert(err, IsNil)
|
|
n, ok := v.(mysql.Time)
|
|
c.Assert(ok, IsTrue)
|
|
c.Assert(n.String(), GreaterEqual, last.Format(mysql.TimeFormat))
|
|
|
|
v, err = builtinSysDate([]interface{}{6}, nil)
|
|
c.Assert(err, IsNil)
|
|
n, ok = v.(mysql.Time)
|
|
c.Assert(ok, IsTrue)
|
|
c.Assert(n.String(), GreaterEqual, last.Format(mysql.TimeFormat))
|
|
|
|
_, err = builtinSysDate([]interface{}{-2}, nil)
|
|
c.Assert(err, NotNil)
|
|
}
|
|
|
|
func (s *testBuiltinSuite) TestCurrentDate(c *C) {
|
|
last := time.Now()
|
|
v, err := builtinCurrentDate(nil, nil)
|
|
c.Assert(err, IsNil)
|
|
n, ok := v.(mysql.Time)
|
|
c.Assert(ok, IsTrue)
|
|
c.Assert(n.String(), GreaterEqual, last.Format(mysql.DateFormat))
|
|
}
|