refactored internal/time/time.go into sql/time.go to avoid import cycle

angelamayxie · angelamayxie · commit e9291ce96bea · 2025-07-23T10:26:53.000-07:00
diff --git a/enginetest/enginetests.go b/enginetest/enginetests.go
@@ -6147,6 +6147,20 @@ func TestSQLLogicTests(t *testing.T, harness Harness) {
 	}
 }
 
+func TestTimeQueryTests(t *testing.T, harness Harness) {
+	for _, script := range queries.TimeQueryTests {
+		if sh, ok := harness.(SkippingHarness); ok {
+			if sh.SkipQueryTest(script.Name) {
+				t.Run(script.Name, func(t *testing.T) {
+					t.Skip(script.Name)
+				})
+				continue
+			}
+		}
+		TestScript(t, harness, script)
+	}
+}
+
 // ExecuteNode builds an iterator and then drains it.
 // This is useful for populating actual row counts for `DESCRIBE ANALYZE`.
 func ExecuteNode(ctx *sql.Context, engine QueryEngine, node sql.Node) error {
diff --git a/enginetest/memory_engine_test.go b/enginetest/memory_engine_test.go
@@ -1097,3 +1097,7 @@ func TestSQLLogicTestFiles(t *testing.T) {
 	}
 	logictest.RunTestFiles(h, paths...)
 }
+
+func TestTimeQueryTests(t *testing.T) {
+	enginetest.TestTimeQueryTests(t, enginetest.NewDefaultMemoryHarness())
+}
diff --git a/enginetest/queries/script_queries.go b/enginetest/queries/script_queries.go
@@ -22,7 +22,6 @@ import (
 	"github.com/dolthub/vitess/go/vt/sqlparser"
 	"gopkg.in/src-d/go-errors.v1"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/analyzer/analyzererrors"
 	"github.com/dolthub/go-mysql-server/sql/plan"
@@ -4685,7 +4684,7 @@ CREATE TABLE tab3 (
 				// To match MySQL's behavior, this comes from the operating system's timezone setting
 				// TODO: the "global" shouldn't be necessary here, but GMS goes to session without it
 				Query:    `select @@global.system_time_zone;`,
-				Expected: []sql.Row{{gmstime.SystemTimezoneOffset()}},
+				Expected: []sql.Row{{sql.SystemTimezoneOffset()}},
 			},
 			{
 				// The default time_zone setting for MySQL is SYSTEM, which means timezone comes from @@system_time_zone
diff --git a/enginetest/queries/time_queries.go b/enginetest/queries/time_queries.go
@@ -0,0 +1,49 @@
+package queries
+
+import (
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/types"
+)
+
+var TimeQueryTests = []ScriptTest{
+	{
+		// time zone tests the current time set as July 23, 2025 at 9:43am America/Phoenix (-7:00) (does not observe
+		// daylight savings time so time zone does not change)
+		Name:        "time zone tests",
+		SetUpScript: []string{},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:    "set time_zone='UTC'",
+				Expected: []sql.Row{{types.NewOkResult(0)}},
+			},
+			{
+				Query:    "select now()",
+				Expected: []sql.Row{{""}}, // july 23, 2025 16:43
+			},
+			{
+				Query:    "set time_zone='-5:00'",
+				Expected: []sql.Row{{types.NewOkResult(0)}},
+			},
+			{
+				Query:    "select now()",
+				Expected: []sql.Row{{""}}, // july 23, 2025 11:43
+			},
+			{
+				// doesn't observe daylight savings time so time zone does not change
+				Query:    "set time_zone='Pacific/Honolulu'",
+				Expected: []sql.Row{{types.NewOkResult(0)}},
+			},
+			{
+				Query:    "select now()",
+				Expected: []sql.Row{{""}}, // july 23, 2025 6:43am
+			},
+			{
+				// https://github.com/dolthub/dolt/issues/9559
+				Skip:  true,
+				Query: "set time_zone='invalid time zone",
+				// update to actual error or error string
+				ExpectedErrStr: "Unknown of incorrect time zone: 'invalid time zone'",
+			},
+		},
+	},
+}
diff --git a/sql/events.go b/sql/events.go
@@ -22,8 +22,6 @@ import (
 	"time"
 
 	"gopkg.in/src-d/go-errors.v1"
-
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 )
 
 const EventDateSpaceTimeFormat = "2006-01-02 15:04:05"
@@ -83,32 +81,32 @@ type EventDefinition struct {
 func (e *EventDefinition) ConvertTimesFromUTCToTz(tz string) *EventDefinition {
 	ne := *e
 	if ne.HasExecuteAt {
-		t, ok := gmstime.ConvertTimeZone(e.ExecuteAt, "+00:00", tz)
+		t, ok := ConvertTimeZone(e.ExecuteAt, "+00:00", tz)
 		if ok {
 			ne.ExecuteAt = t
 		}
 	} else {
-		t, ok := gmstime.ConvertTimeZone(e.Starts, "+00:00", tz)
+		t, ok := ConvertTimeZone(e.Starts, "+00:00", tz)
 		if ok {
 			ne.Starts = t
 		}
 		if ne.HasEnds {
-			t, ok = gmstime.ConvertTimeZone(e.Ends, "+00:00", tz)
+			t, ok = ConvertTimeZone(e.Ends, "+00:00", tz)
 			if ok {
 				ne.Ends = t
 			}
 		}
 	}
 
-	t, ok := gmstime.ConvertTimeZone(e.CreatedAt, "+00:00", tz)
+	t, ok := ConvertTimeZone(e.CreatedAt, "+00:00", tz)
 	if ok {
 		ne.CreatedAt = t
 	}
-	t, ok = gmstime.ConvertTimeZone(e.LastAltered, "+00:00", tz)
+	t, ok = ConvertTimeZone(e.LastAltered, "+00:00", tz)
 	if ok {
 		ne.LastAltered = t
 	}
-	t, ok = gmstime.ConvertTimeZone(e.LastExecuted, "+00:00", tz)
+	t, ok = ConvertTimeZone(e.LastExecuted, "+00:00", tz)
 	if ok {
 		ne.LastExecuted = t
 	}
@@ -363,7 +361,7 @@ var tzRegex = regexp.MustCompile(`(?m)^([+\-])(\d{2}):(\d{2})$`)
 // evaluating valid MySQL datetime and timestamp formats.
 func GetTimeValueFromStringInput(field, t string) (time.Time, error) {
 	// TODO: the time value should be in session timezone rather than system timezone.
-	sessTz := gmstime.SystemTimezoneOffset()
+	sessTz := SystemTimezoneOffset()
 
 	// For MySQL datetime format, it accepts any valid date format
 	// and tries parsing time part first and timezone part if time part is valid.
@@ -407,7 +405,7 @@ func GetTimeValueFromStringInput(field, t string) (time.Time, error) {
 		}
 
 		// convert the time value to the session timezone for display and storage
-		tVal, ok = gmstime.ConvertTimeZone(tVal, inputTz, sessTz)
+		tVal, ok = ConvertTimeZone(tVal, inputTz, sessTz)
 		if !ok {
 			return time.Time{}, fmt.Errorf("invalid time zone: %s", sessTz)
 		}
diff --git a/sql/expression/function/convert_tz.go b/sql/expression/function/convert_tz.go
@@ -17,7 +17,6 @@ package function
 import (
 	"fmt"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
@@ -104,7 +103,7 @@ func (c *ConvertTz) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	}
 
 	if fromStr == "SYSTEM" {
-		fromStr = gmstime.SystemTimezoneOffset()
+		fromStr = sql.SystemTimezoneOffset()
 	}
 
 	toStr, ok := to.(string)
@@ -113,10 +112,10 @@ func (c *ConvertTz) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	}
 
 	if toStr == "SYSTEM" {
-		toStr = gmstime.SystemTimezoneOffset()
+		toStr = sql.SystemTimezoneOffset()
 	}
 
-	converted, success := gmstime.ConvertTimeZone(datetime, fromStr, toStr)
+	converted, success := sql.ConvertTimeZone(datetime, fromStr, toStr)
 	if !success {
 		return nil, nil
 	}
diff --git a/sql/expression/function/date.go b/sql/expression/function/date.go
@@ -22,7 +22,6 @@ import (
 
 	"github.com/shopspring/decimal"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/transform"
@@ -314,7 +313,7 @@ func (ut *UnixTimestamp) Eval(ctx *sql.Context, row sql.Row) (interface{}, error
 		return nil, err
 	}
 
-	ctz, ok := gmstime.ConvertTimeZone(date.(time.Time), stz, "UTC")
+	ctz, ok := sql.ConvertTimeZone(date.(time.Time), stz, "UTC")
 	if ok {
 		date = ctz
 	}
@@ -408,7 +407,7 @@ func (r *FromUnixtime) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	if err != nil {
 		return nil, err
 	}
-	t, _ = gmstime.ConvertTimeZone(t, "UTC", tz)
+	t, _ = sql.ConvertTimeZone(t, "UTC", tz)
 	if len(vals) == 1 {
 		return t, nil // If format is omitted, this function returns a DATETIME value.
 	}
diff --git a/sql/expression/function/time.go b/sql/expression/function/time.go
@@ -22,7 +22,6 @@ import (
 
 	"gopkg.in/src-d/go-errors.v1"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/types"
@@ -1016,7 +1015,7 @@ func (n *Now) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	// If no arguments, just return with 0 precision
 	// The way the parser is implemented 0 should always be passed in; have this here just in case
 	if n.prec == nil {
-		t, ok := gmstime.ConvertTimeZone(currentTime, gmstime.SystemTimezoneOffset(), sessionTimeZone)
+		t, ok := sql.ConvertTimeZone(currentTime, sql.SystemTimezoneOffset(), sessionTimeZone)
 		if !ok {
 			return nil, fmt.Errorf("invalid time zone: %s", sessionTimeZone)
 		}
@@ -1056,7 +1055,7 @@ func (n *Now) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	}
 
 	// Get the timestamp
-	t, ok := gmstime.ConvertTimeZone(currentTime, gmstime.SystemTimezoneOffset(), sessionTimeZone)
+	t, ok := sql.ConvertTimeZone(currentTime, sql.SystemTimezoneOffset(), sessionTimeZone)
 	if !ok {
 		return nil, fmt.Errorf("invalid time zone: %s", sessionTimeZone)
 	}
@@ -1106,7 +1105,7 @@ func SessionTimeZone(ctx *sql.Context) (string, error) {
 	}
 
 	if sessionTimeZone == "SYSTEM" {
-		sessionTimeZone = gmstime.SystemTimezoneOffset()
+		sessionTimeZone = sql.SystemTimezoneOffset()
 	}
 	return sessionTimeZone, nil
 }
diff --git a/sql/information_schema/information_schema.go b/sql/information_schema/information_schema.go
@@ -24,7 +24,6 @@ import (
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/dolthub/vitess/go/vt/sqlparser"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	. "github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/mysql_db"
 	"github.com/dolthub/go-mysql-server/sql/plan"
@@ -965,7 +964,7 @@ func eventsRowIter(ctx *Context, c Catalog) (RowIter, error) {
 			}
 
 			for _, e := range eventDefs {
-				ed := e.ConvertTimesFromUTCToTz(gmstime.SystemTimezoneOffset())
+				ed := e.ConvertTimesFromUTCToTz(SystemTimezoneOffset())
 				var at, intervalVal, intervalField, starts, ends interface{}
 				var eventType, status string
 				if ed.HasExecuteAt {
diff --git a/sql/plan/alter_event.go b/sql/plan/alter_event.go
@@ -22,7 +22,6 @@ import (
 
 	"github.com/dolthub/vitess/go/mysql"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/types"
@@ -241,7 +240,7 @@ func (a *AlterEvent) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)
 	var err error
 	ed := a.Event
 	eventAlteredTime := ctx.QueryTime()
-	sysTz := gmstime.SystemTimezoneOffset()
+	sysTz := sql.SystemTimezoneOffset()
 	ed.LastAltered = eventAlteredTime
 	ed.Definer = a.Definer
 
diff --git a/sql/plan/ddl_event.go b/sql/plan/ddl_event.go
@@ -23,7 +23,6 @@ import (
 
 	"github.com/dolthub/vitess/go/mysql"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/types"
@@ -231,7 +230,7 @@ func (c *CreateEvent) WithExpressions(e ...sql.Expression) (sql.Node, error) {
 func (c *CreateEvent) RowIter(ctx *sql.Context, _ sql.Row) (sql.RowIter, error) {
 	eventCreationTime := ctx.QueryTime()
 	// TODO: event time values are evaluated in 'SYSTEM' TZ for now (should be session TZ)
-	eventDefinition, err := c.GetEventDefinition(ctx, eventCreationTime, eventCreationTime, time.Time{}, gmstime.SystemTimezoneOffset())
+	eventDefinition, err := c.GetEventDefinition(ctx, eventCreationTime, eventCreationTime, time.Time{}, sql.SystemTimezoneOffset())
 	if err != nil {
 		return nil, err
 	}
@@ -562,7 +561,7 @@ func (ost *OnScheduleTimestamp) EvalTime(ctx *sql.Context, tz string) (time.Time
 	if err != nil {
 		return time.Time{}, err
 	}
-	return gmstime.ConvertTimeToLocation(truncatedVal, tz)
+	return sql.ConvertTimeToLocation(truncatedVal, tz)
 }
 
 var _ sql.Node = (*DropEvent)(nil)
diff --git a/sql/plan/show_events.go b/sql/plan/show_events.go
@@ -15,7 +15,6 @@
 package plan
 
 import (
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
@@ -100,7 +99,7 @@ func (s *ShowEvents) RowIter(ctx *sql.Context, row sql.Row) (sql.RowIter, error)
 	for _, event := range s.Events {
 		eventType := "RECURRING"
 		var executeAt, intervalVal, intervalField, starts, ends, status interface{}
-		e := event.ConvertTimesFromUTCToTz(gmstime.SystemTimezoneOffset())
+		e := event.ConvertTimesFromUTCToTz(sql.SystemTimezoneOffset())
 		if e.HasExecuteAt {
 			eventType = "ONE TIME"
 			executeAt = e.ExecuteAt.Format(sql.EventDateSpaceTimeFormat)
diff --git a/sql/rowexec/show.go b/sql/rowexec/show.go
@@ -22,7 +22,6 @@ import (
 	"sort"
 	"strings"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/mysql_db"
 	"github.com/dolthub/go-mysql-server/sql/plan"
@@ -889,7 +888,7 @@ func (b *BaseBuilder) buildShowCreateEvent(ctx *sql.Context, n *plan.ShowCreateE
 	}
 
 	// Convert the Event's timestamps into the session's timezone (they are always stored in UTC)
-	newEvent := n.Event.ConvertTimesFromUTCToTz(gmstime.SystemTimezoneOffset())
+	newEvent := n.Event.ConvertTimesFromUTCToTz(sql.SystemTimezoneOffset())
 	n.Event = *newEvent
 
 	// TODO: fill time_zone with appropriate values
diff --git a/sql/time.go b/sql/time.go
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 // Package time contains low-level utility functions for working with time.Time values and timezones.
-package time
+package sql
 
 import (
 	"errors"
@@ -62,15 +62,15 @@ func MySQLOffsetToDuration(d string) (time.Duration, error) {
 
 // SystemTimezoneOffset returns the current system timezone offset as a MySQL timezone offset (e.g. "+01:00").
 func SystemTimezoneOffset() string {
-	t := time.Now()
+	t := Now()
 	_, offset := t.Zone()
 
 	return SecondsToMySQLOffset(offset)
 }
 
 // SystemTimezoneName returns the current system timezone name.
 func SystemTimezoneName() string {
-	t := time.Now()
+	t := Now()
 	name, _ := t.Zone()
 
 	return name
diff --git a/sql/variables/system_variables.go b/sql/variables/system_variables.go
@@ -24,7 +24,6 @@ import (
 	"github.com/google/uuid"
 	"github.com/sirupsen/logrus"
 
-	gmstime "github.com/dolthub/go-mysql-server/internal/time"
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
@@ -2642,7 +2641,7 @@ var systemVars = map[string]sql.SystemVariable{
 		Dynamic:           false,
 		SetVarHintApplies: false,
 		Type:              types.NewSystemStringType("system_time_zone"),
-		Default:           gmstime.SystemTimezoneName(),
+		Default:           sql.SystemTimezoneName(),
 	},
 	"table_definition_cache": &sql.MysqlSystemVariable{
 		Name:              "table_definition_cache",

Original file line number	Diff line number	Diff line change
`@@ -1097,3 +1097,7 @@ func TestSQLLogicTestFiles(t *testing.T) {`
`1097`	`1097`	`}`
`1098`	`1098`	`logictest.RunTestFiles(h, paths...)`
`1099`	`1099`	`}`
	`1100`	`+`
	`1101`	`+func TestTimeQueryTests(t *testing.T) {`
	`1102`	`+ enginetest.TestTimeQueryTests(t, enginetest.NewDefaultMemoryHarness())`
	`1103`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,6 @@ import (`
`22`	`22`	`"time"`
`23`	`23`
`24`	`24`	`"gopkg.in/src-d/go-errors.v1"`
`25`		`-`
`26`		`- gmstime "github.com/dolthub/go-mysql-server/internal/time"`
`27`	`25`	`)`
`28`	`26`
`29`	`27`	`const EventDateSpaceTimeFormat = "2006-01-02 15:04:05"`
`@@ -83,32 +81,32 @@ type EventDefinition struct {`
`83`	`81`	`func (e EventDefinition) ConvertTimesFromUTCToTz(tz string) EventDefinition {`
`84`	`82`	`ne := *e`
`85`	`83`	`if ne.HasExecuteAt {`
`86`		`- t, ok := gmstime.ConvertTimeZone(e.ExecuteAt, "+00:00", tz)`
	`84`	`+ t, ok := ConvertTimeZone(e.ExecuteAt, "+00:00", tz)`
`87`	`85`	`if ok {`
`88`	`86`	`ne.ExecuteAt = t`
`89`	`87`	`}`
`90`	`88`	`} else {`
`91`		`- t, ok := gmstime.ConvertTimeZone(e.Starts, "+00:00", tz)`
	`89`	`+ t, ok := ConvertTimeZone(e.Starts, "+00:00", tz)`
`92`	`90`	`if ok {`
`93`	`91`	`ne.Starts = t`
`94`	`92`	`}`
`95`	`93`	`if ne.HasEnds {`
`96`		`- t, ok = gmstime.ConvertTimeZone(e.Ends, "+00:00", tz)`
	`94`	`+ t, ok = ConvertTimeZone(e.Ends, "+00:00", tz)`
`97`	`95`	`if ok {`
`98`	`96`	`ne.Ends = t`
`99`	`97`	`}`
`100`	`98`	`}`
`101`	`99`	`}`
`102`	`100`
`103`		`- t, ok := gmstime.ConvertTimeZone(e.CreatedAt, "+00:00", tz)`
	`101`	`+ t, ok := ConvertTimeZone(e.CreatedAt, "+00:00", tz)`
`104`	`102`	`if ok {`
`105`	`103`	`ne.CreatedAt = t`
`106`	`104`	`}`
`107`		`- t, ok = gmstime.ConvertTimeZone(e.LastAltered, "+00:00", tz)`
	`105`	`+ t, ok = ConvertTimeZone(e.LastAltered, "+00:00", tz)`
`108`	`106`	`if ok {`
`109`	`107`	`ne.LastAltered = t`
`110`	`108`	`}`
`111`		`- t, ok = gmstime.ConvertTimeZone(e.LastExecuted, "+00:00", tz)`
	`109`	`+ t, ok = ConvertTimeZone(e.LastExecuted, "+00:00", tz)`
`112`	`110`	`if ok {`
`113`	`111`	`ne.LastExecuted = t`
`114`	`112`	`}`
@@ -363,7 +361,7 @@ var tzRegex = regexp.MustCompile(`(?m)^([+\-])(\d{2}):(\d{2})$`)
`363`	`361`	`// evaluating valid MySQL datetime and timestamp formats.`
`364`	`362`	`func GetTimeValueFromStringInput(field, t string) (time.Time, error) {`
`365`	`363`	`// TODO: the time value should be in session timezone rather than system timezone.`
`366`		`- sessTz := gmstime.SystemTimezoneOffset()`
	`364`	`+ sessTz := SystemTimezoneOffset()`
`367`	`365`
`368`	`366`	`// For MySQL datetime format, it accepts any valid date format`
`369`	`367`	`// and tries parsing time part first and timezone part if time part is valid.`
`@@ -407,7 +405,7 @@ func GetTimeValueFromStringInput(field, t string) (time.Time, error) {`
`407`	`405`	`}`
`408`	`406`
`409`	`407`	`// convert the time value to the session timezone for display and storage`
`410`		`- tVal, ok = gmstime.ConvertTimeZone(tVal, inputTz, sessTz)`
	`408`	`+ tVal, ok = ConvertTimeZone(tVal, inputTz, sessTz)`
`411`	`409`	`if !ok {`
`412`	`410`	`return time.Time{}, fmt.Errorf("invalid time zone: %s", sessTz)`
`413`	`411`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,6 @@ package function`
`17`	`17`	`import (`
`18`	`18`	`"fmt"`
`19`	`19`
`20`		`- gmstime "github.com/dolthub/go-mysql-server/internal/time"`
`21`	`20`	`"github.com/dolthub/go-mysql-server/sql"`
`22`	`21`	`"github.com/dolthub/go-mysql-server/sql/types"`
`23`	`22`	`)`
`@@ -104,7 +103,7 @@ func (c ConvertTz) Eval(ctx sql.Context, row sql.Row) (interface{}, error) {`
`104`	`103`	`}`
`105`	`104`
`106`	`105`	`if fromStr == "SYSTEM" {`
`107`		`- fromStr = gmstime.SystemTimezoneOffset()`
	`106`	`+ fromStr = sql.SystemTimezoneOffset()`
`108`	`107`	`}`
`109`	`108`
`110`	`109`	`toStr, ok := to.(string)`
`@@ -113,10 +112,10 @@ func (c ConvertTz) Eval(ctx sql.Context, row sql.Row) (interface{}, error) {`
`113`	`112`	`}`
`114`	`113`
`115`	`114`	`if toStr == "SYSTEM" {`
`116`		`- toStr = gmstime.SystemTimezoneOffset()`
	`115`	`+ toStr = sql.SystemTimezoneOffset()`
`117`	`116`	`}`
`118`	`117`
`119`		`- converted, success := gmstime.ConvertTimeZone(datetime, fromStr, toStr)`
	`118`	`+ converted, success := sql.ConvertTimeZone(datetime, fromStr, toStr)`
`120`	`119`	`if !success {`
`121`	`120`	`return nil, nil`
`122`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ import (`
`22`	`22`
`23`	`23`	`"github.com/shopspring/decimal"`
`24`	`24`
`25`		`- gmstime "github.com/dolthub/go-mysql-server/internal/time"`
`26`	`25`	`"github.com/dolthub/go-mysql-server/sql"`
`27`	`26`	`"github.com/dolthub/go-mysql-server/sql/expression"`
`28`	`27`	`"github.com/dolthub/go-mysql-server/sql/transform"`
`@@ -314,7 +313,7 @@ func (ut UnixTimestamp) Eval(ctx sql.Context, row sql.Row) (interface{}, error`
`314`	`313`	`return nil, err`
`315`	`314`	`}`
`316`	`315`
`317`		`- ctz, ok := gmstime.ConvertTimeZone(date.(time.Time), stz, "UTC")`
	`316`	`+ ctz, ok := sql.ConvertTimeZone(date.(time.Time), stz, "UTC")`
`318`	`317`	`if ok {`
`319`	`318`	`date = ctz`
`320`	`319`	`}`
`@@ -408,7 +407,7 @@ func (r FromUnixtime) Eval(ctx sql.Context, row sql.Row) (interface{}, error)`
`408`	`407`	`if err != nil {`
`409`	`408`	`return nil, err`
`410`	`409`	`}`
`411`		`- t, _ = gmstime.ConvertTimeZone(t, "UTC", tz)`
	`410`	`+ t, _ = sql.ConvertTimeZone(t, "UTC", tz)`
`412`	`411`	`if len(vals) == 1 {`
`413`	`412`	`return t, nil // If format is omitted, this function returns a DATETIME value.`
`414`	`413`	`}`