snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/query/engine/datetime_functions_test.go

@@ -0,0 +1,891 @@
+package engine
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/schema_pb"
+)
+
+func TestDateTimeFunctions(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	t.Run("CURRENT_DATE function tests", func(t *testing.T) {
+		before := time.Now()
+		result, err := engine.CurrentDate()
+		after := time.Now()
+
+		if err != nil {
+			t.Errorf("CurrentDate failed: %v", err)
+		}
+
+		if result == nil {
+			t.Errorf("CurrentDate returned nil result")
+			return
+		}
+
+		stringVal, ok := result.Kind.(*schema_pb.Value_StringValue)
+		if !ok {
+			t.Errorf("CurrentDate should return string value, got %T", result.Kind)
+			return
+		}
+
+		// Check format (YYYY-MM-DD) with tolerance for midnight boundary crossings
+		beforeDate := before.Format("2006-01-02")
+		afterDate := after.Format("2006-01-02")
+
+		if stringVal.StringValue != beforeDate && stringVal.StringValue != afterDate {
+			t.Errorf("Expected current date %s or %s (due to potential midnight boundary), got %s",
+				beforeDate, afterDate, stringVal.StringValue)
+		}
+	})
+
+	t.Run("CURRENT_TIMESTAMP function tests", func(t *testing.T) {
+		before := time.Now()
+		result, err := engine.CurrentTimestamp()
+		after := time.Now()
+
+		if err != nil {
+			t.Errorf("CurrentTimestamp failed: %v", err)
+		}
+
+		if result == nil {
+			t.Errorf("CurrentTimestamp returned nil result")
+			return
+		}
+
+		timestampVal, ok := result.Kind.(*schema_pb.Value_TimestampValue)
+		if !ok {
+			t.Errorf("CurrentTimestamp should return timestamp value, got %T", result.Kind)
+			return
+		}
+
+		timestamp := time.UnixMicro(timestampVal.TimestampValue.TimestampMicros)
+
+		// Check that timestamp is within reasonable range with small tolerance buffer
+		// Allow for small timing variations, clock precision differences, and NTP adjustments
+		tolerance := 100 * time.Millisecond
+		beforeWithTolerance := before.Add(-tolerance)
+		afterWithTolerance := after.Add(tolerance)
+
+		if timestamp.Before(beforeWithTolerance) || timestamp.After(afterWithTolerance) {
+			t.Errorf("Timestamp %v should be within tolerance of %v to %v (tolerance: %v)",
+				timestamp, before, after, tolerance)
+		}
+	})
+
+	t.Run("NOW function tests", func(t *testing.T) {
+		result, err := engine.Now()
+		if err != nil {
+			t.Errorf("Now failed: %v", err)
+		}
+
+		if result == nil {
+			t.Errorf("Now returned nil result")
+			return
+		}
+
+		// Should return same type as CurrentTimestamp
+		_, ok := result.Kind.(*schema_pb.Value_TimestampValue)
+		if !ok {
+			t.Errorf("Now should return timestamp value, got %T", result.Kind)
+		}
+	})
+
+	t.Run("CURRENT_TIME function tests", func(t *testing.T) {
+		result, err := engine.CurrentTime()
+		if err != nil {
+			t.Errorf("CurrentTime failed: %v", err)
+		}
+
+		if result == nil {
+			t.Errorf("CurrentTime returned nil result")
+			return
+		}
+
+		stringVal, ok := result.Kind.(*schema_pb.Value_StringValue)
+		if !ok {
+			t.Errorf("CurrentTime should return string value, got %T", result.Kind)
+			return
+		}
+
+		// Check format (HH:MM:SS)
+		if len(stringVal.StringValue) != 8 || stringVal.StringValue[2] != ':' || stringVal.StringValue[5] != ':' {
+			t.Errorf("CurrentTime should return HH:MM:SS format, got %s", stringVal.StringValue)
+		}
+	})
+}
+
+func TestExtractFunction(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	// Create a test timestamp: 2023-06-15 14:30:45
+	// Use local time to avoid timezone conversion issues
+	testTime := time.Date(2023, 6, 15, 14, 30, 45, 0, time.Local)
+	testTimestamp := &schema_pb.Value{
+		Kind: &schema_pb.Value_TimestampValue{
+			TimestampValue: &schema_pb.TimestampValue{
+				TimestampMicros: testTime.UnixMicro(),
+			},
+		},
+	}
+
+	tests := []struct {
+		name      string
+		part      DatePart
+		value     *schema_pb.Value
+		expected  int64
+		expectErr bool
+	}{
+		{
+			name:      "Extract YEAR",
+			part:      PartYear,
+			value:     testTimestamp,
+			expected:  2023,
+			expectErr: false,
+		},
+		{
+			name:      "Extract MONTH",
+			part:      PartMonth,
+			value:     testTimestamp,
+			expected:  6,
+			expectErr: false,
+		},
+		{
+			name:      "Extract DAY",
+			part:      PartDay,
+			value:     testTimestamp,
+			expected:  15,
+			expectErr: false,
+		},
+		{
+			name:      "Extract HOUR",
+			part:      PartHour,
+			value:     testTimestamp,
+			expected:  14,
+			expectErr: false,
+		},
+		{
+			name:      "Extract MINUTE",
+			part:      PartMinute,
+			value:     testTimestamp,
+			expected:  30,
+			expectErr: false,
+		},
+		{
+			name:      "Extract SECOND",
+			part:      PartSecond,
+			value:     testTimestamp,
+			expected:  45,
+			expectErr: false,
+		},
+		{
+			name:      "Extract QUARTER from June",
+			part:      PartQuarter,
+			value:     testTimestamp,
+			expected:  2, // June is in Q2
+			expectErr: false,
+		},
+		{
+			name:      "Extract from string date",
+			part:      PartYear,
+			value:     &schema_pb.Value{Kind: &schema_pb.Value_StringValue{StringValue: "2023-06-15"}},
+			expected:  2023,
+			expectErr: false,
+		},
+		{
+			name:      "Extract from Unix timestamp",
+			part:      PartYear,
+			value:     &schema_pb.Value{Kind: &schema_pb.Value_Int64Value{Int64Value: testTime.Unix()}},
+			expected:  2023,
+			expectErr: false,
+		},
+		{
+			name:      "Extract from null value",
+			part:      PartYear,
+			value:     nil,
+			expected:  0,
+			expectErr: true,
+		},
+		{
+			name:      "Extract invalid part",
+			part:      DatePart("INVALID"),
+			value:     testTimestamp,
+			expected:  0,
+			expectErr: true,
+		},
+		{
+			name:      "Extract from invalid string",
+			part:      PartYear,
+			value:     &schema_pb.Value{Kind: &schema_pb.Value_StringValue{StringValue: "invalid-date"}},
+			expected:  0,
+			expectErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := engine.Extract(tt.part, tt.value)
+
+			if tt.expectErr {
+				if err == nil {
+					t.Errorf("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			if result == nil {
+				t.Errorf("Extract returned nil result")
+				return
+			}
+
+			intVal, ok := result.Kind.(*schema_pb.Value_Int64Value)
+			if !ok {
+				t.Errorf("Extract should return int64 value, got %T", result.Kind)
+				return
+			}
+
+			if intVal.Int64Value != tt.expected {
+				t.Errorf("Expected %d, got %d", tt.expected, intVal.Int64Value)
+			}
+		})
+	}
+}
+
+func TestDateTruncFunction(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	// Create a test timestamp: 2023-06-15 14:30:45.123456
+	testTime := time.Date(2023, 6, 15, 14, 30, 45, 123456000, time.Local) // nanoseconds
+	testTimestamp := &schema_pb.Value{
+		Kind: &schema_pb.Value_TimestampValue{
+			TimestampValue: &schema_pb.TimestampValue{
+				TimestampMicros: testTime.UnixMicro(),
+			},
+		},
+	}
+
+	tests := []struct {
+		name          string
+		precision     string
+		value         *schema_pb.Value
+		expectErr     bool
+		expectedCheck func(result time.Time) bool // Custom check function
+	}{
+		{
+			name:      "Truncate to second",
+			precision: "second",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 6 && result.Day() == 15 &&
+					result.Hour() == 14 && result.Minute() == 30 && result.Second() == 45 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate to minute",
+			precision: "minute",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 6 && result.Day() == 15 &&
+					result.Hour() == 14 && result.Minute() == 30 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate to hour",
+			precision: "hour",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 6 && result.Day() == 15 &&
+					result.Hour() == 14 && result.Minute() == 0 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate to day",
+			precision: "day",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 6 && result.Day() == 15 &&
+					result.Hour() == 0 && result.Minute() == 0 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate to month",
+			precision: "month",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 6 && result.Day() == 1 &&
+					result.Hour() == 0 && result.Minute() == 0 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate to quarter",
+			precision: "quarter",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				// June (month 6) should truncate to April (month 4) - start of Q2
+				return result.Year() == 2023 && result.Month() == 4 && result.Day() == 1 &&
+					result.Hour() == 0 && result.Minute() == 0 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate to year",
+			precision: "year",
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 1 && result.Day() == 1 &&
+					result.Hour() == 0 && result.Minute() == 0 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate with plural precision",
+			precision: "minutes", // Test plural form
+			value:     testTimestamp,
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				return result.Year() == 2023 && result.Month() == 6 && result.Day() == 15 &&
+					result.Hour() == 14 && result.Minute() == 30 && result.Second() == 0 &&
+					result.Nanosecond() == 0
+			},
+		},
+		{
+			name:      "Truncate from string date",
+			precision: "day",
+			value:     &schema_pb.Value{Kind: &schema_pb.Value_StringValue{StringValue: "2023-06-15 14:30:45"}},
+			expectErr: false,
+			expectedCheck: func(result time.Time) bool {
+				// The result should be the start of day 2023-06-15 in local timezone
+				expectedDay := time.Date(2023, 6, 15, 0, 0, 0, 0, result.Location())
+				return result.Equal(expectedDay)
+			},
+		},
+		{
+			name:          "Truncate null value",
+			precision:     "day",
+			value:         nil,
+			expectErr:     true,
+			expectedCheck: nil,
+		},
+		{
+			name:          "Invalid precision",
+			precision:     "invalid",
+			value:         testTimestamp,
+			expectErr:     true,
+			expectedCheck: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := engine.DateTrunc(tt.precision, tt.value)
+
+			if tt.expectErr {
+				if err == nil {
+					t.Errorf("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			if result == nil {
+				t.Errorf("DateTrunc returned nil result")
+				return
+			}
+
+			timestampVal, ok := result.Kind.(*schema_pb.Value_TimestampValue)
+			if !ok {
+				t.Errorf("DateTrunc should return timestamp value, got %T", result.Kind)
+				return
+			}
+
+			resultTime := time.UnixMicro(timestampVal.TimestampValue.TimestampMicros)
+
+			if !tt.expectedCheck(resultTime) {
+				t.Errorf("DateTrunc result check failed for precision %s, got time: %v", tt.precision, resultTime)
+			}
+		})
+	}
+}
+
+// TestDateTimeConstantsInSQL tests that datetime constants work in actual SQL queries
+// This test reproduces the original bug where CURRENT_TIME returned empty values
+func TestDateTimeConstantsInSQL(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	t.Run("CURRENT_TIME in SQL query", func(t *testing.T) {
+		// This is the exact case that was failing
+		result, err := engine.ExecuteSQL(context.Background(), "SELECT CURRENT_TIME FROM user_events LIMIT 1")
+
+		if err != nil {
+			t.Fatalf("SQL execution failed: %v", err)
+		}
+
+		if result.Error != nil {
+			t.Fatalf("Query result has error: %v", result.Error)
+		}
+
+		// Verify we have the correct column and non-empty values
+		if len(result.Columns) != 1 || result.Columns[0] != "current_time" {
+			t.Errorf("Expected column 'current_time', got %v", result.Columns)
+		}
+
+		if len(result.Rows) == 0 {
+			t.Fatal("Expected at least one row")
+		}
+
+		timeValue := result.Rows[0][0].ToString()
+		if timeValue == "" {
+			t.Error("CURRENT_TIME should not return empty value")
+		}
+
+		// Verify HH:MM:SS format
+		if len(timeValue) == 8 && timeValue[2] == ':' && timeValue[5] == ':' {
+			t.Logf("CURRENT_TIME returned valid time: %s", timeValue)
+		} else {
+			t.Errorf("CURRENT_TIME should return HH:MM:SS format, got: %s", timeValue)
+		}
+	})
+
+	t.Run("CURRENT_DATE in SQL query", func(t *testing.T) {
+		result, err := engine.ExecuteSQL(context.Background(), "SELECT CURRENT_DATE FROM user_events LIMIT 1")
+
+		if err != nil {
+			t.Fatalf("SQL execution failed: %v", err)
+		}
+
+		if result.Error != nil {
+			t.Fatalf("Query result has error: %v", result.Error)
+		}
+
+		if len(result.Rows) == 0 {
+			t.Fatal("Expected at least one row")
+		}
+
+		dateValue := result.Rows[0][0].ToString()
+		if dateValue == "" {
+			t.Error("CURRENT_DATE should not return empty value")
+		}
+
+		t.Logf("CURRENT_DATE returned: %s", dateValue)
+	})
+}
+
+// TestFunctionArgumentCountHandling tests that the function evaluation correctly handles
+// both zero-argument and single-argument functions
+func TestFunctionArgumentCountHandling(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	t.Run("Zero-argument function should fail appropriately", func(t *testing.T) {
+		funcExpr := &FuncExpr{
+			Name:  testStringValue(FuncCURRENT_TIME),
+			Exprs: []SelectExpr{}, // Zero arguments - should fail since we removed zero-arg support
+		}
+
+		result, err := engine.evaluateStringFunction(funcExpr, HybridScanResult{})
+		if err == nil {
+			t.Error("Expected error for zero-argument function, but got none")
+		}
+		if result != nil {
+			t.Error("Expected nil result for zero-argument function")
+		}
+
+		expectedError := "function CURRENT_TIME expects exactly 1 argument"
+		if err.Error() != expectedError {
+			t.Errorf("Expected error '%s', got '%s'", expectedError, err.Error())
+		}
+	})
+
+	t.Run("Single-argument function should still work", func(t *testing.T) {
+		funcExpr := &FuncExpr{
+			Name: testStringValue(FuncUPPER),
+			Exprs: []SelectExpr{
+				&AliasedExpr{
+					Expr: &SQLVal{
+						Type: StrVal,
+						Val:  []byte("test"),
+					},
+				},
+			}, // Single argument - should work
+		}
+
+		// Create a mock result
+		mockResult := HybridScanResult{}
+
+		result, err := engine.evaluateStringFunction(funcExpr, mockResult)
+		if err != nil {
+			t.Errorf("Single-argument function failed: %v", err)
+		}
+		if result == nil {
+			t.Errorf("Single-argument function returned nil")
+		}
+	})
+
+	t.Run("Any zero-argument function should fail", func(t *testing.T) {
+		funcExpr := &FuncExpr{
+			Name:  testStringValue("INVALID_FUNCTION"),
+			Exprs: []SelectExpr{}, // Zero arguments - should fail
+		}
+
+		result, err := engine.evaluateStringFunction(funcExpr, HybridScanResult{})
+		if err == nil {
+			t.Error("Expected error for zero-argument function, got nil")
+		}
+		if result != nil {
+			t.Errorf("Expected nil result for zero-argument function, got %v", result)
+		}
+
+		expectedError := "function INVALID_FUNCTION expects exactly 1 argument"
+		if err.Error() != expectedError {
+			t.Errorf("Expected error '%s', got '%s'", expectedError, err.Error())
+		}
+	})
+
+	t.Run("Wrong argument count for single-arg function should fail", func(t *testing.T) {
+		funcExpr := &FuncExpr{
+			Name: testStringValue(FuncUPPER),
+			Exprs: []SelectExpr{
+				&AliasedExpr{Expr: &SQLVal{Type: StrVal, Val: []byte("test1")}},
+				&AliasedExpr{Expr: &SQLVal{Type: StrVal, Val: []byte("test2")}},
+			}, // Two arguments - should fail for UPPER
+		}
+
+		result, err := engine.evaluateStringFunction(funcExpr, HybridScanResult{})
+		if err == nil {
+			t.Errorf("Expected error for wrong argument count, got nil")
+		}
+		if result != nil {
+			t.Errorf("Expected nil result for wrong argument count, got %v", result)
+		}
+
+		expectedError := "function UPPER expects exactly 1 argument"
+		if err.Error() != expectedError {
+			t.Errorf("Expected error '%s', got '%s'", expectedError, err.Error())
+		}
+	})
+}
+
+// Helper function to create a string value for testing
+func testStringValue(s string) StringGetter {
+	return &testStringValueImpl{value: s}
+}
+
+type testStringValueImpl struct {
+	value string
+}
+
+func (s *testStringValueImpl) String() string {
+	return s.value
+}
+
+// TestExtractFunctionSQL tests the EXTRACT function through SQL execution
+func TestExtractFunctionSQL(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	testCases := []struct {
+		name        string
+		sql         string
+		expectError bool
+		checkValue  func(t *testing.T, result *QueryResult)
+	}{
+		{
+			name:        "Extract YEAR from current_date",
+			sql:         "SELECT EXTRACT(YEAR FROM current_date) AS year_value FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				yearStr := result.Rows[0][0].ToString()
+				currentYear := time.Now().Year()
+				if yearStr != fmt.Sprintf("%d", currentYear) {
+					t.Errorf("Expected current year %d, got %s", currentYear, yearStr)
+				}
+			},
+		},
+		{
+			name:        "Extract MONTH from current_date",
+			sql:         "SELECT EXTRACT('MONTH', current_date) AS month_value FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				monthStr := result.Rows[0][0].ToString()
+				currentMonth := time.Now().Month()
+				if monthStr != fmt.Sprintf("%d", int(currentMonth)) {
+					t.Errorf("Expected current month %d, got %s", int(currentMonth), monthStr)
+				}
+			},
+		},
+		{
+			name:        "Extract DAY from current_date",
+			sql:         "SELECT EXTRACT('DAY', current_date) AS day_value FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				dayStr := result.Rows[0][0].ToString()
+				currentDay := time.Now().Day()
+				if dayStr != fmt.Sprintf("%d", currentDay) {
+					t.Errorf("Expected current day %d, got %s", currentDay, dayStr)
+				}
+			},
+		},
+		{
+			name:        "Extract HOUR from current_timestamp",
+			sql:         "SELECT EXTRACT('HOUR', current_timestamp) AS hour_value FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				hourStr := result.Rows[0][0].ToString()
+				// Just check it's a valid hour (0-23)
+				hour, err := strconv.Atoi(hourStr)
+				if err != nil {
+					t.Errorf("Expected valid hour integer, got %s", hourStr)
+				}
+				if hour < 0 || hour > 23 {
+					t.Errorf("Expected hour 0-23, got %d", hour)
+				}
+			},
+		},
+		{
+			name:        "Extract MINUTE from current_timestamp",
+			sql:         "SELECT EXTRACT('MINUTE', current_timestamp) AS minute_value FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				minuteStr := result.Rows[0][0].ToString()
+				// Just check it's a valid minute (0-59)
+				minute, err := strconv.Atoi(minuteStr)
+				if err != nil {
+					t.Errorf("Expected valid minute integer, got %s", minuteStr)
+				}
+				if minute < 0 || minute > 59 {
+					t.Errorf("Expected minute 0-59, got %d", minute)
+				}
+			},
+		},
+		{
+			name:        "Extract QUARTER from current_date",
+			sql:         "SELECT EXTRACT('QUARTER', current_date) AS quarter_value FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				quarterStr := result.Rows[0][0].ToString()
+				quarter, err := strconv.Atoi(quarterStr)
+				if err != nil {
+					t.Errorf("Expected valid quarter integer, got %s", quarterStr)
+				}
+				if quarter < 1 || quarter > 4 {
+					t.Errorf("Expected quarter 1-4, got %d", quarter)
+				}
+			},
+		},
+		{
+			name:        "Multiple EXTRACT functions",
+			sql:         "SELECT EXTRACT(YEAR FROM current_date) AS year_val, EXTRACT(MONTH FROM current_date) AS month_val, EXTRACT(DAY FROM current_date) AS day_val FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				if len(result.Rows[0]) != 3 {
+					t.Fatalf("Expected 3 columns, got %d", len(result.Rows[0]))
+				}
+
+				// Check year
+				yearStr := result.Rows[0][0].ToString()
+				currentYear := time.Now().Year()
+				if yearStr != fmt.Sprintf("%d", currentYear) {
+					t.Errorf("Expected current year %d, got %s", currentYear, yearStr)
+				}
+
+				// Check month
+				monthStr := result.Rows[0][1].ToString()
+				currentMonth := time.Now().Month()
+				if monthStr != fmt.Sprintf("%d", int(currentMonth)) {
+					t.Errorf("Expected current month %d, got %s", int(currentMonth), monthStr)
+				}
+
+				// Check day
+				dayStr := result.Rows[0][2].ToString()
+				currentDay := time.Now().Day()
+				if dayStr != fmt.Sprintf("%d", currentDay) {
+					t.Errorf("Expected current day %d, got %s", currentDay, dayStr)
+				}
+			},
+		},
+		{
+			name:        "EXTRACT with invalid date part",
+			sql:         "SELECT EXTRACT('INVALID_PART', current_date) FROM user_events LIMIT 1",
+			expectError: true,
+			checkValue:  nil,
+		},
+		{
+			name:        "EXTRACT with wrong number of arguments",
+			sql:         "SELECT EXTRACT('YEAR') FROM user_events LIMIT 1",
+			expectError: true,
+			checkValue:  nil,
+		},
+		{
+			name:        "EXTRACT with too many arguments",
+			sql:         "SELECT EXTRACT('YEAR', current_date, 'extra') FROM user_events LIMIT 1",
+			expectError: true,
+			checkValue:  nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := engine.ExecuteSQL(context.Background(), tc.sql)
+
+			if tc.expectError {
+				if err == nil && result.Error == nil {
+					t.Errorf("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			if result.Error != nil {
+				t.Errorf("Query result has error: %v", result.Error)
+				return
+			}
+
+			if tc.checkValue != nil {
+				tc.checkValue(t, result)
+			}
+		})
+	}
+}
+
+// TestDateTruncFunctionSQL tests the DATE_TRUNC function through SQL execution
+func TestDateTruncFunctionSQL(t *testing.T) {
+	engine := NewTestSQLEngine()
+
+	testCases := []struct {
+		name        string
+		sql         string
+		expectError bool
+		checkValue  func(t *testing.T, result *QueryResult)
+	}{
+		{
+			name:        "DATE_TRUNC to day",
+			sql:         "SELECT DATE_TRUNC('day', current_timestamp) AS truncated_day FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				// The result should be a timestamp value, just check it's not empty
+				timestampStr := result.Rows[0][0].ToString()
+				if timestampStr == "" {
+					t.Error("Expected non-empty timestamp result")
+				}
+			},
+		},
+		{
+			name:        "DATE_TRUNC to hour",
+			sql:         "SELECT DATE_TRUNC('hour', current_timestamp) AS truncated_hour FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				timestampStr := result.Rows[0][0].ToString()
+				if timestampStr == "" {
+					t.Error("Expected non-empty timestamp result")
+				}
+			},
+		},
+		{
+			name:        "DATE_TRUNC to month",
+			sql:         "SELECT DATE_TRUNC('month', current_timestamp) AS truncated_month FROM user_events LIMIT 1",
+			expectError: false,
+			checkValue: func(t *testing.T, result *QueryResult) {
+				if len(result.Rows) == 0 {
+					t.Fatal("Expected at least one row")
+				}
+				timestampStr := result.Rows[0][0].ToString()
+				if timestampStr == "" {
+					t.Error("Expected non-empty timestamp result")
+				}
+			},
+		},
+		{
+			name:        "DATE_TRUNC with invalid precision",
+			sql:         "SELECT DATE_TRUNC('invalid', current_timestamp) FROM user_events LIMIT 1",
+			expectError: true,
+			checkValue:  nil,
+		},
+		{
+			name:        "DATE_TRUNC with wrong number of arguments",
+			sql:         "SELECT DATE_TRUNC('day') FROM user_events LIMIT 1",
+			expectError: true,
+			checkValue:  nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := engine.ExecuteSQL(context.Background(), tc.sql)
+
+			if tc.expectError {
+				if err == nil && result.Error == nil {
+					t.Errorf("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+
+			if result.Error != nil {
+				t.Errorf("Query result has error: %v", result.Error)
+				return
+			}
+
+			if tc.checkValue != nil {
+				tc.checkValue(t, result)
+			}
+		})
+	}
+}