evalEngine: Implement TIME_TO_SEC

go/vt/vtgate/evalengine/compiler_asm.go

@@ -3818,6 +3818,19 @@
 	}, "FN FROM_DAYS INT64(SP-1)")
 }
 
+func (asm *assembler) Fn_TIME_TO_SEC() {
+	asm.emit(func(env *ExpressionEnv) int {
+		if env.vm.stack[env.vm.sp-1] == nil {
+			return 1
+		}
+		d := env.vm.stack[env.vm.sp-1].(*evalTemporal)
+
+		sec := d.dt.Time.Hour()*3600 + d.dt.Time.Minute()*60 + d.dt.Time.Second()
+		env.vm.stack[env.vm.sp-1] = env.vm.arena.newEvalInt64(int64(sec))
+		return 1
+	}, "FN TIME_TO_SEC TIME(SP-1)")
+}
+
 func (asm *assembler) Fn_QUARTER() {
 	asm.emit(func(env *ExpressionEnv) int {
 		if env.vm.stack[env.vm.sp-1] == nil {

go/vt/vtgate/evalengine/fn_time.go

@@ -119,6 +119,10 @@
 		CallExpr
 	}
 
+	builtinTimeToSec struct {
+		CallExpr
+	}
+
 	builtinQuarter struct {
 		CallExpr
 	}
@@ -183,6 +187,7 @@
 var _ IR = (*builtinLastDay)(nil)
 var _ IR = (*builtinToDays)(nil)
 var _ IR = (*builtinFromDays)(nil)
+var _ IR = (*builtinTimeToSec)(nil)
 var _ IR = (*builtinQuarter)(nil)
 var _ IR = (*builtinSecond)(nil)
 var _ IR = (*builtinTime)(nil)
@@ -1327,6 +1332,43 @@
 	return ctype{Type: sqltypes.Date, Flag: arg.Flag | flagNullable}, nil
 }
 
+func (b *builtinTimeToSec) eval(env *ExpressionEnv) (eval, error) {
+	arg, err := b.arg1(env)
+	if arg == nil {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	d := evalToTime(arg, -1)
+	if d == nil {
+		return nil, nil
+	}
+
+	sec := d.dt.Time.Hour()*3600 + d.dt.Time.Minute()*60 + d.dt.Time.Second()
+	return newEvalInt64(int64(sec)), nil
+}
+
+func (call *builtinTimeToSec) compile(c *compiler) (ctype, error) {
+	arg, err := call.Arguments[0].compile(c)
+	if err != nil {
+		return ctype{}, err
+	}
+
+	skip := c.compileNullCheck1(arg)
+
+	switch arg.Type {
+	case sqltypes.Date, sqltypes.Datetime, sqltypes.Time:
+	default:
+		c.asm.Convert_xT(1, -1)
+	}
+
+	c.asm.Fn_TIME_TO_SEC()
+	c.asm.jumpDestination(skip)
+	return ctype{Type: sqltypes.Int64, Col: collationNumeric, Flag: arg.Flag | flagNullable}, nil
+}
+
 func (b *builtinQuarter) eval(env *ExpressionEnv) (eval, error) {
 	date, err := b.arg1(env)
 	if err != nil {

go/vt/vtgate/evalengine/testcases/cases.go

@@ -133,6 +133,7 @@ var Cases = []TestCase{
 	{Run: FnLastDay},
 	{Run: FnToDays},
 	{Run: FnFromDays},
+	{Run: FnTimeToSec},
 	{Run: FnQuarter},
 	{Run: FnSecond},
 	{Run: FnTime},
@@ -1816,6 +1817,26 @@ func FnFromDays(yield Query) {
 	}
 }
 
+func FnTimeToSec(yield Query) {
+	for _, d := range inputConversions {
+		yield(fmt.Sprintf("FROM_DAYS(%s)", d), nil)
+	}
+
+	time := []string{
+		`0`,
+		`'00:00:00'`,
+		`'22:23:00'`,
+		`'00:39:38'`,
+		`'000220`,
+		`'2003-09-03 00:39:38'`,
+		`'2003-09-03'`,
+	}
+
+	for _, t := range time {
+		yield(fmt.Sprintf("TIME_TO_SEC(%s)", t), nil)
+	}
+}
+
 func FnQuarter(yield Query) {
 	for _, d := range inputConversions {
 		yield(fmt.Sprintf("QUARTER(%s)", d), nil)

go/vt/vtgate/evalengine/translate_builtin.go

@@ -429,6 +429,11 @@
 			return nil, argError(method)
 		}
 		return &builtinFromDays{CallExpr: call}, nil
+	case "time_to_sec":
+		if len(args) != 1 {
+			return nil, argError(method)
+		}
+		return &builtinTimeToSec{CallExpr: call}, nil
 	case "quarter":
 		if len(args) != 1 {
 			return nil, argError(method)