vibesql-executor 0.2.0

Query execution engine for vibesql SQL database
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Date/time field extraction functions
//!
//! Implements YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, and EXTRACT functions.

use vibesql_types::SqlValue;

use crate::errors::ExecutorError;

/// YEAR(date) - Extract year from date/timestamp
/// SQL:1999 Section 6.32: Datetime field extraction
pub fn year(args: &[SqlValue]) -> Result<SqlValue, ExecutorError> {
    if args.len() != 1 {
        return Err(ExecutorError::UnsupportedFeature(
            "YEAR requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        SqlValue::Null => Ok(SqlValue::Null),
        SqlValue::Date(d) => Ok(SqlValue::Integer(d.year as i64)),
        SqlValue::Timestamp(ts) => Ok(SqlValue::Integer(ts.date.year as i64)),
        _ => Err(ExecutorError::UnsupportedFeature(
            "YEAR requires date or timestamp argument".to_string(),
        )),
    }
}

/// MONTH(date) - Extract month from date/timestamp
/// SQL:1999 Section 6.32: Datetime field extraction
pub fn month(args: &[SqlValue]) -> Result<SqlValue, ExecutorError> {
    if args.len() != 1 {
        return Err(ExecutorError::UnsupportedFeature(
            "MONTH requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        SqlValue::Null => Ok(SqlValue::Null),
        SqlValue::Date(d) => Ok(SqlValue::Integer(d.month as i64)),
        SqlValue::Timestamp(ts) => Ok(SqlValue::Integer(ts.date.month as i64)),
        _ => Err(ExecutorError::UnsupportedFeature(
            "MONTH requires date or timestamp argument".to_string(),
        )),
    }
}

/// DAY(date) - Extract day from date/timestamp
/// SQL:1999 Section 6.32: Datetime field extraction
pub fn day(args: &[SqlValue]) -> Result<SqlValue, ExecutorError> {
    if args.len() != 1 {
        return Err(ExecutorError::UnsupportedFeature(
            "DAY requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        SqlValue::Null => Ok(SqlValue::Null),
        SqlValue::Date(d) => Ok(SqlValue::Integer(d.day as i64)),
        SqlValue::Timestamp(ts) => Ok(SqlValue::Integer(ts.date.day as i64)),
        _ => Err(ExecutorError::UnsupportedFeature(
            "DAY requires date or timestamp argument".to_string(),
        )),
    }
}

/// HOUR(time) - Extract hour from time/timestamp
/// SQL:1999 Section 6.32: Datetime field extraction
pub fn hour(args: &[SqlValue]) -> Result<SqlValue, ExecutorError> {
    if args.len() != 1 {
        return Err(ExecutorError::UnsupportedFeature(
            "HOUR requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        SqlValue::Null => Ok(SqlValue::Null),
        SqlValue::Time(t) => Ok(SqlValue::Integer(t.hour as i64)),
        SqlValue::Timestamp(ts) => Ok(SqlValue::Integer(ts.time.hour as i64)),
        _ => Err(ExecutorError::UnsupportedFeature(
            "HOUR requires time or timestamp argument".to_string(),
        )),
    }
}

/// MINUTE(time) - Extract minute from time/timestamp
/// SQL:1999 Section 6.32: Datetime field extraction
pub fn minute(args: &[SqlValue]) -> Result<SqlValue, ExecutorError> {
    if args.len() != 1 {
        return Err(ExecutorError::UnsupportedFeature(
            "MINUTE requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        SqlValue::Null => Ok(SqlValue::Null),
        SqlValue::Time(t) => Ok(SqlValue::Integer(t.minute as i64)),
        SqlValue::Timestamp(ts) => Ok(SqlValue::Integer(ts.time.minute as i64)),
        _ => Err(ExecutorError::UnsupportedFeature(
            "MINUTE requires time or timestamp argument".to_string(),
        )),
    }
}

/// SECOND(time) - Extract second from time/timestamp
/// SQL:1999 Section 6.32: Datetime field extraction
pub fn second(args: &[SqlValue]) -> Result<SqlValue, ExecutorError> {
    if args.len() != 1 {
        return Err(ExecutorError::UnsupportedFeature(
            "SECOND requires exactly 1 argument".to_string(),
        ));
    }

    match &args[0] {
        SqlValue::Null => Ok(SqlValue::Null),
        SqlValue::Time(t) => Ok(SqlValue::Integer(t.second as i64)),
        SqlValue::Timestamp(ts) => Ok(SqlValue::Integer(ts.time.second as i64)),
        _ => Err(ExecutorError::UnsupportedFeature(
            "SECOND requires time or timestamp argument".to_string(),
        )),
    }
}