best guess at this

Author: James Cor

enginetest/queries/queries.go

@@ -10506,23 +10506,23 @@ var VersionedScripts = []ScriptTest{
 var DateParseQueries = []QueryTest{
 	{
 		Query:    "SELECT STR_TO_DATE('Jan 3, 2000', '%b %e, %Y')",
-		Expected: []sql.Row{{"2000-01-03"}},
+		Expected: []sql.Row{{time.Date(2000, time.January, 3, 0, 0, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('01,5,2013', '%d,%m,%Y')",
-		Expected: []sql.Row{{"2013-05-01"}},
+		Expected: []sql.Row{{time.Date(2013, time.May, 1, 0, 0, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('May 1, 2013','%M %d,%Y')",
-		Expected: []sql.Row{{"2013-05-01"}},
+		Expected: []sql.Row{{time.Date(2013, time.May, 1, 0, 0, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('a09:30:17','a%h:%i:%s')",
-		Expected: []sql.Row{{"09:30:17"}},
+		Expected: []sql.Row{{time.Date(-1, time.November, 30, 9, 30, 17, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('A09:30:17','A%h:%i:%s')",
-		Expected: []sql.Row{{"09:30:17"}},
+		Expected: []sql.Row{{time.Date(-1, time.November, 30, 9, 30, 17, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('a09:30:17','%h:%i:%s')",
@@ -10534,39 +10534,39 @@ var DateParseQueries = []QueryTest{
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('09:30:17a','%h:%i:%s')",
-		Expected: []sql.Row{{"09:30:17"}},
+		Expected: []sql.Row{{time.Date(-1, time.November, 30, 9, 30, 17, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('09:30:17 pm','%h:%i:%s %p')",
-		Expected: []sql.Row{{"21:30:17"}},
+		Expected: []sql.Row{{time.Date(-1, time.November, 30, 9, 30, 17, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('9','%m')",
-		Expected: []sql.Row{{"0000-09-00"}},
+		Expected: []sql.Row{{time.Date(0, time.August, 31, 0, 0, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('9','%s')",
-		Expected: []sql.Row{{"00:00:09"}},
+		Expected: []sql.Row{{time.Date(-1, time.November, 30, 0, 0, 9, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('01/02/99 314', '%m/%e/%y %f')",
-		Expected: []sql.Row{{"1999-01-02 00:00:00.314000"}},
+		Expected: []sql.Row{{time.Date(1999, time.January, 2, 0, 0, 0, 314000, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('01/02/99 0', '%m/%e/%y %f')",
-		Expected: []sql.Row{{"1999-01-02 00:00:00.000000"}},
+		Expected: []sql.Row{{time.Date(1999, time.January, 2, 0, 0, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('01/02/99 05:14:12 PM', '%m/%e/%y %r')",
-		Expected: []sql.Row{{"1999-01-02 17:14:12"}},
+		Expected: []sql.Row{{time.Date(1999, time.January, 2, 5, 14, 12, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('May 3, 10:23:00 2000', '%b %e, %H:%i:%s %Y')",
-		Expected: []sql.Row{{"2000-05-03 10:23:00"}},
+		Expected: []sql.Row{{time.Date(2000, time.May, 3, 10, 23, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('May 3, 10:23:00 PM 2000', '%b %e, %h:%i:%s %p %Y')",
-		Expected: []sql.Row{{"2000-05-03 22:23:00"}},
+		Expected: []sql.Row{{time.Date(2000, time.May, 3, 10, 23, 0, 0, time.UTC)}},
 	},
 	{
 		Query:    "SELECT STR_TO_DATE('May 3, 10:23:00 PM 2000', '%b %e, %H:%i:%s %p %Y')", // cannot use 24 hour time (%H) with AM/PM (%p)

sql/expression/function/registry.go

@@ -218,7 +218,7 @@ var BuiltIns = []sql.Function{
 	sql.Function1{Name: "sleep", Fn: NewSleep},
 	sql.Function1{Name: "soundex", Fn: NewSoundex},
 	sql.Function1{Name: "sqrt", Fn: NewSqrt},
-	sql.FunctionN{Name: "str_to_date", Fn: NewStrToDate},
+	sql.Function2{Name: "str_to_date", Fn: NewStrToDate},
 	sql.FunctionN{Name: "subdate", Fn: NewSubDate},
 	sql.Function2{Name: "point", Fn: spatial.NewPoint},
 	sql.FunctionN{Name: "linestring", Fn: spatial.NewLineString},

sql/expression/function/str_to_date.go

@@ -3,23 +3,12 @@ package function
 import (
 	"fmt"
 
-	"github.com/dolthub/go-mysql-server/sql/planbuilder/dateparse"
-
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/expression"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder/dateparse"
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
-// NewStrToDate constructs a new function expression from the given child expressions.
-func NewStrToDate(args ...sql.Expression) (sql.Expression, error) {
-	if len(args) != 2 {
-		return nil, sql.ErrInvalidArgumentNumber.New("STR_TO_DATE", 2, len(args))
-	}
-	return &StrToDate{
-		Date:   args[0],
-		Format: args[1],
-	}, nil
-}
-
 // StrToDate defines the built-in function STR_TO_DATE(str, format)
 type StrToDate struct {
 	Date   sql.Expression
@@ -29,40 +18,91 @@ type StrToDate struct {
 var _ sql.FunctionExpression = (*StrToDate)(nil)
 var _ sql.CollationCoercible = (*StrToDate)(nil)
 
+// NewStrToDate constructs a new function expression from the given child expressions.
+func NewStrToDate(arg1, arg2 sql.Expression) sql.Expression {
+	return &StrToDate{
+		Date:   arg1,
+		Format: arg2,
+	}
+}
+
+func (s *StrToDate) FunctionName() string {
+	return "str_to_date"
+}
+
 // Description implements sql.FunctionExpression
-func (s StrToDate) Description() string {
+func (s *StrToDate) Description() string {
 	return "parses the date/datetime/timestamp expression according to the format specifier."
 }
 
 // Resolved returns whether the node is resolved.
-func (s StrToDate) Resolved() bool {
+func (s *StrToDate) Resolved() bool {
 	dateResolved := s.Date == nil || s.Date.Resolved()
 	formatResolved := s.Format == nil || s.Format.Resolved()
 	return dateResolved && formatResolved
 }
 
-func (s StrToDate) String() string {
+func (s *StrToDate) String() string {
 	return fmt.Sprintf("%s(%s,%s)", s.FunctionName(), s.Date, s.Format)
 }
 
 // Type returns the expression type.
-func (s StrToDate) Type() sql.Type {
-	// TODO: precision
+func (s *StrToDate) Type() sql.Type {
+	// TODO: depending on the format, the return type can be a date, datetime or timestamp
+	//  just make best guess for now
+	formatLit, isLit := s.Format.(*expression.Literal)
+	if !isLit {
+		return types.Datetime
+	}
+	format, err := formatLit.Eval(nil, nil)
+	if err != nil {
+		return types.Datetime
+	}
+	formatStr, isStr := format.(string)
+	if !isStr {
+		return types.Datetime
+	}
+
+	hasDate, hasTime, err := dateparse.HasDateOrTime(formatStr)
+	if err != nil {
+		return types.Datetime
+	}
+	if hasDate && hasTime {
+		return types.Datetime
+	}
+	if hasDate {
+		return types.Date
+	}
+	if hasTime {
+		return types.Time
+	}
 	return types.Datetime
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.
-func (StrToDate) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
+func (*StrToDate) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
 	return sql.Collation_binary, 5
 }
 
 // IsNullable returns whether the expression can be null.
-func (s StrToDate) IsNullable() bool {
+func (s *StrToDate) IsNullable() bool {
 	return true
 }
 
+// Children returns the children expressions of this expression.
+func (s *StrToDate) Children() []sql.Expression {
+	return []sql.Expression{s.Date, s.Format}
+}
+
+func (s *StrToDate) WithChildren(children ...sql.Expression) (sql.Expression, error) {
+	if len(children) != 2 {
+		return nil, sql.ErrInvalidArgumentNumber.New("STR_TO_DATE", 2, len(children))
+	}
+	return NewStrToDate(children[0], children[1]), nil
+}
+
 // Eval evaluates the given row and returns a result.
-func (s StrToDate) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+func (s *StrToDate) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	date, err := s.Date.Eval(ctx, row)
 	if err != nil {
 		return nil, err
@@ -93,23 +133,3 @@ func (s StrToDate) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	// but depends on strict sql_mode with NO_ZERO_DATE or NO_ZERO_IN_DATE modes enabled.
 	return goTime, nil
 }
-
-// Children returns the children expressions of this expression.
-func (s StrToDate) Children() []sql.Expression {
-	children := make([]sql.Expression, 0, 2)
-	if s.Date != nil {
-		children = append(children, s.Date)
-	}
-	if s.Format != nil {
-		children = append(children, s.Format)
-	}
-	return children
-}
-
-func (s StrToDate) WithChildren(children ...sql.Expression) (sql.Expression, error) {
-	return NewStrToDate(children...)
-}
-
-func (s StrToDate) FunctionName() string {
-	return "str_to_date"
-}

sql/planbuilder/dateparse/date.go

@@ -11,6 +11,32 @@ var (
 	timeSpecifiers = []uint8{'f', 'H', 'h', 'I', 'i', 'k', 'l', 'p', 'r', 'S', 's', 'T'}
 )
 
+func HasDateOrTime(format string) (bool, bool, error) {
+	_, specifiers, err := parsersFromFormatString(format)
+	if err != nil {
+		return false, false, err
+	}
+
+	hasDate := false
+	for _, s := range dateSpecifiers {
+		if _, ok := specifiers[s]; ok {
+			hasDate = true
+			break
+		}
+	}
+
+	hasTime := false
+	for _, s := range timeSpecifiers {
+		if _, ok := specifiers[s]; ok {
+			hasTime = true
+			break
+		}
+	}
+
+	return hasDate, hasTime, nil
+}
+
+
 // ParseDateWithFormat parses the date string according to the given
 // format string, as defined in the MySQL specification.
 //
@@ -26,33 +52,25 @@ func ParseDateWithFormat(date, format string) (interface{}, error) {
 		return nil, err
 	}
 
-	hasDate := false
 	for _, s := range dateSpecifiers {
 		if _, ok := specifiers[s]; ok {
-			hasDate = true
 			break
 		}
 	}
-
-	hasTime := false
 	_, hasAmPm := specifiers['p']
 	for _, s := range timeSpecifiers {
 		if _, ok := specifiers[s]; ok {
 			// validate that am/pm is not used with 24 hour time specifiers
 			if (s == 'H' || s == 'k' || s == 'T') && hasAmPm {
 				return nil, fmt.Errorf("cannot use 24 hour time (H) with AM/PM (p)")
 			}
-			hasTime = true
 			break
 		}
 	}
 
 	// trim all leading and trailing whitespace
 	date = strings.TrimSpace(date)
 
-	// convert to all lowercase
-	//date = strings.ToLower(date)
-
 	var dt datetime
 	target := date
 	for _, parser := range parsers {
@@ -64,18 +82,52 @@ func ParseDateWithFormat(date, format string) (interface{}, error) {
 		target = rest
 	}
 
-	var result string
-	if hasDate && hasTime {
-		result = fmt.Sprintf("%s %s", evaluateDate(dt), evaluateTime(dt))
-	} else if hasTime {
-		result = fmt.Sprintf("%s", evaluateTime(dt))
-	} else if hasDate {
-		result = fmt.Sprintf("%s", evaluateDate(dt))
-	} else {
-		return nil, fmt.Errorf("no value to evaluate")
+	if dt.isEmpty() {
+		return nil, nil
+	}
+
+	// TODO: depending on if it's a date or time we should return a different type
+	var year, month, day, hours, minutes, seconds, milliseconds, microseconds, nanoseconds int
+	if dt.year != nil {
+		year = int(*dt.year)
+	}
+	if dt.month != nil {
+		month = int(*dt.month)
+	}
+	if dt.day != nil {
+		day = int(*dt.day)
+	}
+	if dt.dayOfYear != nil {
+		// offset from Jan 1st by the specified number of days
+		dayOffsetted := time.Date(year, time.January, 0, 0, 0, 0, 0, time.Local).AddDate(0, 0, int(*dt.dayOfYear))
+		month = int(dayOffsetted.Month())
+		day = dayOffsetted.Day()
+	}
+
+	if dt.hours != nil {
+		hours = int(*dt.hours)
+	}
+	if dt.minutes != nil {
+		minutes = int(*dt.minutes)
+	}
+	if dt.seconds != nil {
+		seconds = int(*dt.seconds)
+	}
+	if dt.milliseconds != nil {
+		milliseconds = int(*dt.milliseconds)
+	}
+	if dt.microseconds != nil {
+		microseconds = int(*dt.microseconds)
+	}
+	if dt.nanoseconds != nil {
+		nanoseconds = int(*dt.nanoseconds)
 	}
+	// convert partial seconds to nanoseconds
+	nanosecondDuration := time.Microsecond*time.Duration(microseconds) +
+		time.Millisecond*time.Duration(milliseconds) +
+		time.Nanosecond*time.Duration(nanoseconds)
 
-	return result, nil
+	return time.Date(year, time.Month(month), day, hours, minutes, seconds, int(nanosecondDuration), time.UTC), nil
 }
 
 // Convert the user-defined format string into a slice of parser functions

sql/planbuilder/dateparse/eval.go

@@ -5,7 +5,9 @@ import (
 	"time"
 )
 
-func evaluateDate(dt datetime) string {
+// TODO: delete file
+
+func evaluateDate(dt datetime) time.Time {
 	var year, month, day int
 
 	if dt.year != nil {
@@ -27,10 +29,10 @@ func evaluateDate(dt datetime) string {
 		day = dayOffsetted.Day()
 	}
 
-	return fillWithZero(year, 4) + "-" + fillWithZero(month, 2) + "-" + fillWithZero(day, 2)
+	return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.Local)
 }
 
-func evaluateTime(dt datetime) string {
+func evaluateTime(dt datetime) time.Time {
 	var hours, minutes, seconds, milliseconds, microseconds, nanoseconds int
 
 	if dt.hours != nil {
@@ -68,7 +70,7 @@ func evaluateTime(dt datetime) string {
 		t = t + "." + fillWithZero(int(nanosecondDuration), 6)
 	}
 
-	return t
+	return time.Date(0, 0, 0, hours, minutes, seconds, int(nanosecondDuration), time.Local)
 }
 
 func fillWithZero(n int, length int) string {