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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

extern crate chrono;

use chrono::DateTime;
use chrono::Datelike;
use chrono::NaiveDate;
use chrono::TimeZone;
use chrono::Timelike;
use chrono::Utc;
use chrono::Weekday;
use gitql_core::value::Value;

pub fn date_extract_date(inputs: &[Value]) -> Value {
    let argument_type = inputs[0].data_type();
    if argument_type.is_date() {
        return inputs[0].clone();
    }
    let timestamp = inputs[0].as_date_time();
    Value::Date(timestamp)
}

pub fn date_current_date(_inputs: &[Value]) -> Value {
    let time_stamp = Utc::now().timestamp();
    Value::Date(time_stamp)
}

pub fn date_current_time(_inputs: &[Value]) -> Value {
    let time_stamp = Utc::now().timestamp();
    let datetime = DateTime::from_timestamp(time_stamp, 0).unwrap();
    let time = datetime.format("%H:%M:%S").to_string();
    Value::Time(time)
}

pub fn date_current_timestamp(_inputs: &[Value]) -> Value {
    let time_stamp = Utc::now().timestamp();
    Value::DateTime(time_stamp)
}

pub fn date_make_date(inputs: &[Value]) -> Value {
    let year = inputs[0].as_int() as i32;
    let day_of_year = inputs[1].as_int() as u32;
    let date = NaiveDate::from_yo_opt(year, day_of_year).unwrap();
    let datetime = date.and_hms_opt(0, 0, 0).unwrap();
    Value::Date(Utc.from_utc_datetime(&datetime).timestamp())
}

pub fn date_make_time(inputs: &[Value]) -> Value {
    let hour = inputs[0].as_int();
    let minute = inputs[1].as_int();
    let second = inputs[2].as_int();
    Value::Time(format!("{}:{:02}:{:02}", hour, minute, second))
}

pub fn date_day(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer(parsed_date.day().into())
}

pub fn date_dayname(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let day_name = match parsed_date.weekday() {
        Weekday::Mon => "Monday",
        Weekday::Tue => "Tuesday",
        Weekday::Wed => "Wednesday",
        Weekday::Thu => "Thursday",
        Weekday::Fri => "Friday",
        Weekday::Sat => "Saturday",
        Weekday::Sun => "Sunday",
    };
    Value::Text(day_name.to_string())
}

pub fn date_monthname(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let month_name = match parsed_date.month() {
        1 => "January",
        2 => "February",
        3 => "March",
        4 => "April",
        5 => "May",
        6 => "June",
        7 => "July",
        8 => "August",
        9 => "September",
        10 => "October",
        11 => "November",
        12 => "December",
        _ => "",
    };
    Value::Text(month_name.to_string())
}

pub fn date_hour(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date_time();
    let date_time = DateTime::from_timestamp(date, 0);
    let dt = date_time.unwrap().time();
    Value::Integer(dt.hour() as i64)
}

pub fn date_minute(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date_time();
    let date_time = DateTime::from_timestamp(date, 0);
    let dt = date_time.unwrap().time();
    Value::Integer(dt.minute() as i64)
}

pub fn date_is_date(inputs: &[Value]) -> Value {
    Value::Boolean(inputs[0].data_type().is_date())
}

pub fn date_day_of_week(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer(parsed_date.weekday().number_from_sunday().into())
}

pub fn date_day_of_month(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer(parsed_date.day().into())
}

pub fn date_day_of_year(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer(parsed_date.ordinal().into())
}

pub fn date_week_of_year(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();

    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let native_date = parsed_date.date_naive();
    let first_day_of_year = NaiveDate::from_ymd_opt(native_date.year(), 1, 1).unwrap();
    let days_diff = native_date
        .signed_duration_since(first_day_of_year)
        .num_days();
    let week_offset = match first_day_of_year.weekday() {
        Weekday::Mon => 0,
        _ => 1,
    };

    let days_with_offset = days_diff + week_offset;
    Value::Integer(((days_with_offset / 7) as u32 + 1).into())
}

pub fn date_year_and_week(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let year = parsed_date.year();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let native_date = parsed_date.date_naive();
    let first_day_of_year = NaiveDate::from_ymd_opt(native_date.year(), 1, 1).unwrap();
    let days_diff = native_date
        .signed_duration_since(first_day_of_year)
        .num_days();
    let week_offset = match first_day_of_year.weekday() {
        Weekday::Mon => 0,
        _ => 1,
    };

    let days_with_offset = days_diff + week_offset;
    let week_number = (days_with_offset / 7) as u32 + 1;
    Value::Text(format!("{}{}", year, week_number))
}

pub fn date_quarter(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let month = parsed_date.month() as i64;
    Value::Integer((month - 1) / 3 + 1)
}

pub fn date_year(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer(parsed_date.year().into())
}

pub fn date_month(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer(parsed_date.month().into())
}

pub fn date_weekday(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    Value::Integer((parsed_date.weekday().number_from_monday() - 1) as i64)
}

pub fn date_to_days(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let days_since_year_0 = parsed_date.ordinal0() as i64;
    let year = parsed_date.year() as i64;
    let leap_years = (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400;
    let non_leap_years = year - leap_years;
    let days = 365 * non_leap_years + 366 * leap_years + days_since_year_0;
    Value::Integer(days)
}

pub fn date_last_day(inputs: &[Value]) -> Value {
    let date = inputs[0].as_date();
    let parsed_date = DateTime::from_timestamp(date, 0).unwrap();
    let (year, month) = (parsed_date.year(), parsed_date.month());

    let curr_month_start = NaiveDate::from_ymd_opt(year, month, 1).unwrap();
    let next_month_start = if month < 12 {
        NaiveDate::from_ymd_opt(year, month + 1, 1)
    } else {
        NaiveDate::from_ymd_opt(year + 1, 1, 1)
    }
    .unwrap();
    let days_in_month = next_month_start - curr_month_start;

    let parsed_date = parsed_date.with_day(1).unwrap();
    let last_day = parsed_date + days_in_month - chrono::Duration::days(1);

    Value::Date(last_day.timestamp())
}