sql, function: add weekday and dayofweek

Signed-off-by: bake <bake@192k.pw>
src-d · ajnavarro · Oct 31, 2018 · Oct 21, 2018 · Oct 21, 2018 · Oct 25, 2018
commit 9c054d21ceb448ddf9116537864a2dfb895cf4dc
@@ -57,7 +57,7 @@ We support and actively test against certain third-party clients to ensure compa
 
 - `IS_BINARY(blob)`: Returns whether a BLOB is a binary file or not.
 - `SUBSTRING(str,pos)`, `SUBSTRING(str,pos,len)`: Return a substring from the provided string.
-- Date and Timestamp functions: `YEAR(date)`, `MONTH(date)`, `DAY(date)`, `HOUR(date)`, `MINUTE(date)`, `SECOND(date)`, `DAYOFYEAR(date)`.
+- Date and Timestamp functions: `YEAR(date)`, `MONTH(date)`, `DAY(date)`, `WEEKDAY(date)`, `HOUR(date)`, `MINUTE(date)`, `SECOND(date)`, `DAYOFWEEK(date)`, `DAYOFYEAR(date)`.
 - `ARRAY_LENGTH(json)`: If the json representation is an array, this function returns its size.
 - `SPLIT(str,sep)`: Receives a string and a separator and returns the parts of the string split by the separator as a JSON array of strings.
 - `CONCAT(...)`: Concatenate any group of fields into a single string.

@@ -91,6 +91,8 @@
 
 ## Time functions
 - DAY
+- WEEKDAY
+- DAYOFWEEK
 - DAYOFYEAR
 - HOUR
 - MINUTE

@@ -27,9 +27,11 @@ var Defaults = sql.Functions{
 	"year":          sql.Function1(NewYear),
 	"month":         sql.Function1(NewMonth),
 	"day":           sql.Function1(NewDay),
+	"weekday":       sql.Function1(NewWeekday),
 	"hour":          sql.Function1(NewHour),
 	"minute":        sql.Function1(NewMinute),
 	"second":        sql.Function1(NewSecond),
+	"dayofweek":     sql.Function1(NewDayOfWeek),
 	"dayofyear":     sql.Function1(NewDayOfYear),
 	"array_length":  sql.Function1(NewArrayLength),
 	"split":         sql.Function2(NewSplit),

@@ -124,6 +124,37 @@ func (d *Day) TransformUp(f sql.TransformExprFunc) (sql.Expression, error) {
 	return f(NewDay(child))
 }
 
+// Weekday is a function that returns the weekday of a date where 0 = Monday,
+// ..., 6 = Sunday.
+type Weekday struct {
+	expression.UnaryExpression
+}
+
+// NewWeekday creates a new Weekday UDF.
+func NewWeekday(date sql.Expression) sql.Expression {
+	return &Weekday{expression.UnaryExpression{Child: date}}
+}
+
+func (d *Weekday) String() string { return fmt.Sprintf("WEEKDAY(%s)", d.Child) }
+
+// Type implements the Expression interface.
+func (d *Weekday) Type() sql.Type { return sql.Int32 }
+
+// Eval implements the Expression interface.
+func (d *Weekday) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	return getDatePart(ctx, d.UnaryExpression, row, weekday)
+}
+
+// TransformUp implements the Expression interface.
+func (d *Weekday) TransformUp(f sql.TransformExprFunc) (sql.Expression, error) {
+	child, err := d.Child.TransformUp(f)
+	if err != nil {
+		return nil, err
+	}
+
+	return f(NewWeekday(child))
+}
+
 // Hour is a function that returns the hour of a date.
 type Hour struct {
 	expression.UnaryExpression
@@ -214,6 +245,37 @@ func (s *Second) TransformUp(f sql.TransformExprFunc) (sql.Expression, error) {
 	return f(NewSecond(child))
 }
 
+// DayOfWeek is a function that returns the day of the week from a date where
+// 1 = Sunday, ..., 7 = Saturday.
+type DayOfWeek struct {
+	expression.UnaryExpression
+}
+
+// NewDayOfWeek creates a new DayOfWeek UDF.
+func NewDayOfWeek(date sql.Expression) sql.Expression {
+	return &DayOfWeek{expression.UnaryExpression{Child: date}}
+}
+
+func (d *DayOfWeek) String() string { return fmt.Sprintf("DAYOFWEEK(%s)", d.Child) }
+
+// Type implements the Expression interface.
+func (d *DayOfWeek) Type() sql.Type { return sql.Int32 }
+
+// Eval implements the Expression interface.
+func (d *DayOfWeek) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	return getDatePart(ctx, d.UnaryExpression, row, dayOfWeek)
+}
+
+// TransformUp implements the Expression interface.
+func (d *DayOfWeek) TransformUp(f sql.TransformExprFunc) (sql.Expression, error) {
+	child, err := d.Child.TransformUp(f)
+	if err != nil {
+		return nil, err
+	}
+
+	return f(NewDayOfWeek(child))
+}
+
 // DayOfYear is a function that returns the day of the year from a date.
 type DayOfYear struct {
 	expression.UnaryExpression
@@ -258,8 +320,10 @@ var (
 	year      = datePartFunc((time.Time).Year)
 	month     = datePartFunc(func(t time.Time) int { return int(t.Month()) })
 	day       = datePartFunc((time.Time).Day)
+	weekday   = datePartFunc(func(t time.Time) int { return (int(t.Weekday()) + 6) % 7 })
 	hour      = datePartFunc((time.Time).Hour)
 	minute    = datePartFunc((time.Time).Minute)
 	second    = datePartFunc((time.Time).Second)
+	dayOfWeek = datePartFunc(func(t time.Time) int { return int(t.Weekday()) + 1%7 })
 	dayOfYear = datePartFunc((time.Time).YearDay)
 )
@@ -107,6 +107,37 @@ func TestTime_Day(t *testing.T) {
 	}
 }
 
+func TestTime_Weekday(t *testing.T) {
+	f := NewWeekday(expression.NewGetField(0, sql.Text, "foo", false))
+	ctx := sql.NewEmptyContext()
+
+	testCases := []struct {
+		name     string
+		row      sql.Row
+		expected interface{}
+		err      bool
+	}{
+		{"null date", sql.NewRow(nil), nil, false},
+		{"invalid type", sql.NewRow([]byte{0, 1, 2}), nil, false},
+		{"date as string", sql.NewRow(stringDate), int32(1), false},
+		{"date as time", sql.NewRow(time.Now()), int32(time.Now().UTC().Weekday()+6) % 7, false},
+		{"date as unix timestamp", sql.NewRow(int64(tsDate)), int32(6), false},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+			val, err := f.Eval(ctx, tt.row)
+			if tt.err {
+				require.Error(err)
+			} else {
+				require.NoError(err)
+				require.Equal(tt.expected, val)
+			}
+		})
+	}
+}
+
 func TestTime_Hour(t *testing.T) {
 	f := NewHour(expression.NewGetField(0, sql.Text, "foo", false))
 	ctx := sql.NewEmptyContext()
@@ -199,6 +230,37 @@ func TestTime_Second(t *testing.T) {
 	}
 }
 
+func TestTime_DayOfWeek(t *testing.T) {
+	f := NewDayOfWeek(expression.NewGetField(0, sql.Text, "foo", false))
+	ctx := sql.NewEmptyContext()
+
+	testCases := []struct {
+		name     string
+		row      sql.Row
+		expected interface{}
+		err      bool
+	}{
+		{"null date", sql.NewRow(nil), nil, false},
+		{"invalid type", sql.NewRow([]byte{0, 1, 2}), nil, false},
+		{"date as string", sql.NewRow(stringDate), int32(3), false},
+		{"date as time", sql.NewRow(time.Now()), int32(time.Now().UTC().Weekday()+1) % 7, false},
+		{"date as unix timestamp", sql.NewRow(int64(tsDate)), int32(1), false},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+			val, err := f.Eval(ctx, tt.row)
+			if tt.err {
+				require.Error(err)
+			} else {
+				require.NoError(err)
+				require.Equal(tt.expected, val)
+			}
+		})
+	}
+}
+
 func TestTime_DayOfYear(t *testing.T) {
 	f := NewDayOfYear(expression.NewGetField(0, sql.Text, "foo", false))
 	ctx := sql.NewEmptyContext()
-Original file line number
+Diff line change
@@ Expand Up / @@ -91,6 +91,8 @@ @@
     ## Time functions
     - DAY
+    - WEEKDAY
+    - DAYOFWEEK
     - DAYOFYEAR
     - HOUR
     - MINUTE
@@ Expand Down @@