From unixtime

enginetest/queries/queries.go

@@ -5575,9 +5575,9 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: "select from_unixtime(i) from mytable order by 1",
 		Expected: []sql.Row{
-			{time.Unix(1, 0)},
-			{time.Unix(2, 0)},
-			{time.Unix(3, 0)},
+			{UnixTimeInLocal(1, 0)},
+			{UnixTimeInLocal(2, 0)},
+			{UnixTimeInLocal(3, 0)},
 		},
 	},
 	// TODO: add additional tests for other functions. Every function needs an engine test to ensure it works correctly
@@ -11768,3 +11768,9 @@ func MustParseTime(layout, value string) time.Time {
 	}
 	return parsed
 }
+
+func UnixTimeInLocal(sec, nsec int64) time.Time {
+	t := time.Unix(sec, nsec)
+	_, offset := t.Zone()
+	return t.Add(time.Second * time.Duration(offset)).In(time.UTC)
+}

enginetest/queries/script_queries.go

@@ -3055,6 +3055,64 @@ CREATE TABLE tab3 (
 			},
 		},
 	},
+	{
+		Name:    "from_unixtime",
+		Dialect: "mysql",
+		Assertions: []ScriptTestAssertion{
+			// null parameter
+			{
+				Query:    "select from_unixtime(null)",
+				Expected: []sql.Row{{nil}},
+			},
+			{
+				Query:    "select from_unixtime(1, null)",
+				Expected: []sql.Row{{nil}},
+			},
+			// out of range
+			{
+				Query:    "select from_unixtime(-1)",
+				Expected: []sql.Row{{nil}},
+			},
+			{
+				Query:    "select from_unixtime(32536771200)",
+				Expected: []sql.Row{{nil}},
+			},
+			// in +8:00
+			{
+				Query:    "set @@session.time_zone='+08:00'",
+				Expected: []sql.Row{{}},
+			},
+			{
+				Query:    "select from_unixtime(1)",
+				Expected: []sql.Row{{time.Unix(1, 0).Add(time.Hour * 8).In(time.UTC)}},
+			},
+			{
+				Query:    "select from_unixtime(32536771199)",
+				Expected: []sql.Row{{time.Unix(32536771199, 0).Add(time.Hour * 8).In(time.UTC)}},
+			},
+			{
+				Query:    "SELECT FROM_UNIXTIME(1,'%Y %D %M %H:%i:%s %x')",
+				Expected: []sql.Row{{"1970 1st January 08:00:01 1970"}},
+			},
+			// in utc
+			{
+				Query:    "set @@session.time_zone='UTC'",
+				Expected: []sql.Row{{}},
+			},
+			{
+				Query:    "select from_unixtime(1)",
+				Expected: []sql.Row{{time.Unix(1, 0).In(time.UTC)}},
+			},
+			{
+				Query:    "select from_unixtime(32536771199)",
+				Expected: []sql.Row{{time.Unix(32536771199, 0).In(time.UTC)}},
+			},
+			{
+				Query:    "SELECT FROM_UNIXTIME(1,'%Y %D %M %H:%i:%s %x')",
+				Expected: []sql.Row{{"1970 1st January 00:00:01 1970"}},
+			},
+		},
+	},
 	{
 		Name:    "unix_timestamp with non UTC timezone",
 		Dialect: "mysql",

sql/expression/function/date.go

@@ -111,6 +111,7 @@ var _ sql.FunctionExpression = (*UnixTimestamp)(nil)
 var _ sql.CollationCoercible = (*UnixTimestamp)(nil)
 
 const MaxUnixTimeMicroSecs = 32536771199999999
+const MaxUnixTimeSecs = 32536771199
 
 // canEval returns if the expression contains an expression that cannot be evaluated without sql.Context or sql.Row.
 func canEval(expr sql.Expression) bool {
@@ -354,14 +355,20 @@ func (ut *UnixTimestamp) String() string {
 
 // FromUnixtime converts the argument to a datetime.
 type FromUnixtime struct {
-	*UnaryFunc
+	expression.NaryExpression
 }
 
 var _ sql.FunctionExpression = (*FromUnixtime)(nil)
 var _ sql.CollationCoercible = (*FromUnixtime)(nil)
 
-func NewFromUnixtime(arg sql.Expression) sql.Expression {
-	return &FromUnixtime{NewUnaryFunc(arg, "FROM_UNIXTIME", types.DatetimeMaxPrecision)}
+// NewFromUnixtime https://dev.mysql.com/doc/refman/8.4/en/date-and-time-functions.html#function_from-unixtime
+func NewFromUnixtime(args ...sql.Expression) (sql.Expression, error) {
+	switch len(args) {
+	case 1, 2:
+		return &FromUnixtime{expression.NaryExpression{ChildExpressions: args}}, nil
+	default:
+		return nil, sql.ErrInvalidArgumentNumber.New("FROM_UNIXTIME", 2, len(args))
+	}
 }
 
 // Description implements sql.FunctionExpression
@@ -375,28 +382,74 @@ func (*FromUnixtime) CollationCoercibility(ctx *sql.Context) (collation sql.Coll
 }
 
 func (r *FromUnixtime) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
-	val, err := r.EvalChild(ctx, row)
+	vals := make([]interface{}, len(r.ChildExpressions))
+	for i, e := range r.ChildExpressions {
+		val, err := e.Eval(ctx, row)
+		if err != nil {
+			return nil, err
+		}
+		vals[i] = val
+	}
+
+	// TODO support decimal value in timestamp
+	n, _, err := types.Int64.Convert(ctx, vals[0])
 	if err != nil {
 		return nil, err
 	}
-
-	if val == nil {
+	if n == nil {
 		return nil, nil
 	}
-
-	n, _, err := types.Int64.Convert(ctx, val)
+	sec := n.(int64)
+	if sec > MaxUnixTimeSecs || sec < 0 {
+		return nil, nil
+	}
+	t := time.Unix(sec, 0).In(time.UTC)
+	tz, err := SessionTimeZone(ctx)
 	if err != nil {
 		return nil, err
 	}
-
-	return time.Unix(n.(int64), 0), nil
+	t, _ = gmstime.ConvertTimeZone(t, "UTC", tz)
+	if len(vals) == 1 {
+		return t, nil // If format is omitted, this function returns a DATETIME value.
+	}
+	format, _, err := types.Text.Convert(ctx, vals[1])
+	if err != nil {
+		return nil, err
+	}
+	if format == nil {
+		return nil, nil
+	}
+	return formatDate(format.(string), t)
 }
 
 func (r *FromUnixtime) WithChildren(children ...sql.Expression) (sql.Expression, error) {
-	if len(children) != 1 {
-		return nil, sql.ErrInvalidChildrenNumber.New(r, len(children), 1)
+	return NewFromUnixtime(children...)
+}
+
+func (r *FromUnixtime) FunctionName() string {
+	return "FROM_UNIXTIME"
+}
+
+func (r *FromUnixtime) String() string {
+	switch len(r.ChildExpressions) {
+	case 1:
+		return fmt.Sprintf("FROM_UNIXTIME(%s)", r.ChildExpressions[0])
+	case 2:
+		return fmt.Sprintf("FROM_UNIXTIME(%s, %s)", r.ChildExpressions[0], r.ChildExpressions[1])
+	default:
+		return "FROM_UNIXTIME(INVALID_NUMBER_OF_ARGUMENTS)"
+	}
+}
+
+func (r *FromUnixtime) Type() sql.Type {
+	switch len(r.ChildExpressions) {
+	case 1:
+		return types.DatetimeMaxPrecision
+	case 2:
+		return types.Text
+	default:
+		return types.Null
 	}
-	return NewFromUnixtime(children[0]), nil
 }
 
 type CurrDate struct {

sql/expression/function/registry.go

@@ -98,7 +98,7 @@ var BuiltIns = []sql.Function{
 	sql.FunctionN{Name: "format", Fn: NewFormat},
 	sql.Function1{Name: "from_base64", Fn: NewFromBase64},
 	sql.Function1{Name: "from_days", Fn: NewFromDays},
-	sql.Function1{Name: "from_unixtime", Fn: NewFromUnixtime},
+	sql.FunctionN{Name: "from_unixtime", Fn: NewFromUnixtime},
 	sql.Function2{Name: "get_format", Fn: NewGetFormat},
 	sql.FunctionN{Name: "greatest", Fn: NewGreatest},
 	sql.Function0{Name: "group_concat", Fn: aggregation.NewEmptyGroupConcat},