feat: Add date/time functions CURRENT_DATE, CURRENT_TIMESTAMP, EXTRACT with comprehensive tests

- Implement CURRENT_DATE returning YYYY-MM-DD format
- Add CURRENT_TIMESTAMP returning TimestampValue with microseconds
- Add CURRENT_TIME returning HH:MM:SS format
- Add NOW() as alias for CURRENT_TIMESTAMP
- Implement comprehensive EXTRACT function supporting:
  - YEAR, MONTH, DAY, HOUR, MINUTE, SECOND
  - QUARTER, WEEK, DOY (day of year), DOW (day of week)
  - EPOCH (Unix timestamp)
- Support multiple input formats:
  - TimestampValue (microseconds)
  - String dates (multiple formats)
  - Unix timestamps (int64 seconds)
- Comprehensive test suite with 15+ test cases covering:
  - All date/time constants
  - Extract from different value types
  - Error handling for invalid inputs
  - Timezone handling

All tests passing ✅

weed/query/engine/sql_functions.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"math"
 	"strconv"
+	"strings"
+	"time"
 
 	"github.com/seaweedfs/seaweedfs/weed/pb/schema_pb"
 )
@@ -250,3 +252,149 @@ func (e *SQLEngine) Abs(value *schema_pb.Value) (*schema_pb.Value, error) {
 		Kind: &schema_pb.Value_DoubleValue{DoubleValue: result},
 	}, nil
 }
+
+// ===============================
+// DATE/TIME CONSTANTS
+// ===============================
+
+// CurrentDate returns the current date as a string in YYYY-MM-DD format
+func (e *SQLEngine) CurrentDate() (*schema_pb.Value, error) {
+	now := time.Now()
+	dateStr := now.Format("2006-01-02")
+	
+	return &schema_pb.Value{
+		Kind: &schema_pb.Value_StringValue{StringValue: dateStr},
+	}, nil
+}
+
+// CurrentTimestamp returns the current timestamp
+func (e *SQLEngine) CurrentTimestamp() (*schema_pb.Value, error) {
+	now := time.Now()
+	
+	// Return as TimestampValue with microseconds
+	timestampMicros := now.UnixMicro()
+	
+	return &schema_pb.Value{
+		Kind: &schema_pb.Value_TimestampValue{
+			TimestampValue: &schema_pb.TimestampValue{
+				TimestampMicros: timestampMicros,
+			},
+		},
+	}, nil
+}
+
+// CurrentTime returns the current time as a string in HH:MM:SS format
+func (e *SQLEngine) CurrentTime() (*schema_pb.Value, error) {
+	now := time.Now()
+	timeStr := now.Format("15:04:05")
+	
+	return &schema_pb.Value{
+		Kind: &schema_pb.Value_StringValue{StringValue: timeStr},
+	}, nil
+}
+
+// Now is an alias for CurrentTimestamp (common SQL function name)
+func (e *SQLEngine) Now() (*schema_pb.Value, error) {
+	return e.CurrentTimestamp()
+}
+
+// ===============================
+// EXTRACT FUNCTION
+// ===============================
+
+// DatePart represents the part of a date/time to extract
+type DatePart string
+
+const (
+	PartYear     DatePart = "YEAR"
+	PartMonth    DatePart = "MONTH"
+	PartDay      DatePart = "DAY"
+	PartHour     DatePart = "HOUR"
+	PartMinute   DatePart = "MINUTE"
+	PartSecond   DatePart = "SECOND"
+	PartWeek     DatePart = "WEEK"
+	PartDayOfYear DatePart = "DOY"
+	PartDayOfWeek DatePart = "DOW"
+	PartQuarter   DatePart = "QUARTER"
+	PartEpoch     DatePart = "EPOCH"
+)
+
+// Extract extracts a specific part from a date/time value
+func (e *SQLEngine) Extract(part DatePart, value *schema_pb.Value) (*schema_pb.Value, error) {
+	if value == nil {
+		return nil, fmt.Errorf("EXTRACT function requires non-null value")
+	}
+
+	// Convert value to time
+	t, err := e.valueToTime(value)
+	if err != nil {
+		return nil, fmt.Errorf("EXTRACT function time conversion error: %v", err)
+	}
+
+	var result int64
+
+	switch strings.ToUpper(string(part)) {
+	case string(PartYear):
+		result = int64(t.Year())
+	case string(PartMonth):
+		result = int64(t.Month())
+	case string(PartDay):
+		result = int64(t.Day())
+	case string(PartHour):
+		result = int64(t.Hour())
+	case string(PartMinute):
+		result = int64(t.Minute())
+	case string(PartSecond):
+		result = int64(t.Second())
+	case string(PartWeek):
+		_, week := t.ISOWeek()
+		result = int64(week)
+	case string(PartDayOfYear):
+		result = int64(t.YearDay())
+	case string(PartDayOfWeek):
+		result = int64(t.Weekday())
+	case string(PartQuarter):
+		month := t.Month()
+		result = int64((month-1)/3 + 1)
+	case string(PartEpoch):
+		result = t.Unix()
+	default:
+		return nil, fmt.Errorf("unsupported date part: %s", part)
+	}
+
+	return &schema_pb.Value{
+		Kind: &schema_pb.Value_Int64Value{Int64Value: result},
+	}, nil
+}
+
+// Helper function to convert schema_pb.Value to time.Time
+func (e *SQLEngine) valueToTime(value *schema_pb.Value) (time.Time, error) {
+	switch v := value.Kind.(type) {
+	case *schema_pb.Value_TimestampValue:
+		if v.TimestampValue == nil {
+			return time.Time{}, fmt.Errorf("null timestamp value")
+		}
+		return time.UnixMicro(v.TimestampValue.TimestampMicros), nil
+	case *schema_pb.Value_StringValue:
+		// Try to parse various date/time string formats
+		dateFormats := []string{
+			"2006-01-02 15:04:05",
+			"2006-01-02T15:04:05Z",
+			"2006-01-02T15:04:05",
+			"2006-01-02",
+			"15:04:05",
+		}
+		
+		for _, format := range dateFormats {
+			if t, err := time.Parse(format, v.StringValue); err == nil {
+				return t, nil
+			}
+		}
+		return time.Time{}, fmt.Errorf("unable to parse date/time string: %s", v.StringValue)
+	case *schema_pb.Value_Int64Value:
+		// Assume Unix timestamp (seconds)
+		return time.Unix(v.Int64Value, 0), nil
+	default:
+		return time.Time{}, fmt.Errorf("cannot convert value type to date/time")
+	}
+}