mode &= 7;

if (!(mode & WEEK_MONDAY_FIRST)) {

mode ^= WEEK_FIRST_WEEKDAY;

}

return mode;

uint32_t minute, uint32_t second, uint16_t type) {

bool time = hour > (type == TIME_TIME ? TIME_MAX_HOUR : 23) || minute > 59 || second > 59;

if (type == TIME_TIME) {

return time;

} else {

return time || check_date(year, month, day);

}

if (month == 2 && day == 29 && doris::is_leap(year)) {

return false;

}

if (year > 9999 || month == 0 || month > 12 || day > S_DAYS_IN_MONTH[month] || day == 0) {

return true;

}

return false;

const cctz::time_zone* local_time_zone) {

const char* ptr = date_str;

const char* end = date_str + len;

// ONLY 2, 6 can follow by a space

const static int allow_space_mask = 4 | 64;

const static int MAX_DATE_PARTS = 8;

uint32_t date_val[MAX_DATE_PARTS];

int32_t date_len[MAX_DATE_PARTS];

_neg = false;

// Skip space character

while (ptr < end && check_space(*ptr)) {

ptr++;

}

if (ptr == end || !isdigit(*ptr)) {

return false;

}

// Fix year length

const char* pos = ptr;

while (pos < end && (isdigit(*pos) || *pos == 'T')) {

pos++;

}

int year_len = 4;

int digits = pos - ptr;

bool is_interval_format = false;

bool has_bar = false;

// Compatible with MySQL.

// For YYYYMMDD/YYYYMMDDHHMMSS is 4 digits years

if (pos == end || *pos == '.') {

if (digits == 4 || digits == 8 || digits >= 14) {

year_len = 4;

} else {

year_len = 2;

}

is_interval_format = true;

}

int field_idx = 0;

int field_len = year_len;

long sec_offset = 0;

while (ptr < end && isdigit(*ptr) && field_idx < MAX_DATE_PARTS - 1) {

const char* start = ptr;

int temp_val = 0;

bool scan_to_delim = (!is_interval_format) && (field_idx != 6);

while (ptr < end && isdigit(*ptr) && (scan_to_delim || field_len--)) {

temp_val = temp_val * 10 + (*ptr++ - '0');

}

// Impossible

if (temp_val > 999999L) {

return false;

}

date_val[field_idx] = temp_val;

date_len[field_idx] = ptr - start;

field_len = 2;

if (ptr == end) {

field_idx++;

break;

}

// timezone

if (UNLIKELY((field_idx > 2 ||

!has_bar) /*dont treat xxxx-xx-xx:xx:xx as xxxx-xx(-xx:xx:xx)*/

&& time_zone_begins(ptr, end))) {

if (local_time_zone == nullptr) {

return false;

}

auto get_tz_offset = [&](const std::string& str_tz,

const cctz::time_zone* local_time_zone) -> long {

cctz::time_zone given_tz {};

if (!TimezoneUtils::find_cctz_time_zone(str_tz, given_tz)) {

throw Exception {ErrorCode::INVALID_ARGUMENT, ""};

}

auto given = cctz::convert(cctz::civil_second {}, given_tz);

auto local = cctz::convert(cctz::civil_second {}, *local_time_zone);

// these two values is absolute time. so they are negative. need to use (-local) - (-given)

return std::chrono::duration_cast<std::chrono::seconds>(given - local).count();

};

try {

sec_offset = get_tz_offset(std::string {ptr, end},

local_time_zone); // use the whole remain string

} catch ([[maybe_unused]] Exception& e) {

return false; // invalid format

}

field_idx++;

break;

}

if (field_idx == 2 && *ptr == 'T') {

// YYYYMMDDTHHMMDD, skip 'T' and continue

ptr++;

field_idx++;

continue;

}

// Second part

if (field_idx == 5) {

if (*ptr == '.') {

ptr++;

field_len = 6;

} else if (isdigit(*ptr)) {

field_idx++;

break;

}

field_idx++;

continue;

}

// escape separator

while (ptr < end && (check_date_punct(*ptr) || check_space(*ptr))) {

if (check_space(*ptr)) {

if (((1 << field_idx) & allow_space_mask) == 0) {

return false;

}

}

if (*ptr == '-') {

has_bar = true;

}

ptr++;

}

field_idx++;

}

int num_field = field_idx;

if (num_field <= 3) {

_type = TIME_DATE;

} else {

_type = TIME_DATETIME;

}

if (!is_interval_format) {

year_len = date_len[0];

}

for (; field_idx < MAX_DATE_PARTS; ++field_idx) {

date_len[field_idx] = 0;

date_val[field_idx] = 0;

}

if (year_len == 2) {

if (date_val[0] < YY_PART_YEAR) {

date_val[0] += 2000;

} else {

date_val[0] += 1900;

}

}

if (num_field < 3) {

return false;

}

if (!check_range_and_set_time(date_val[0], date_val[1], date_val[2], date_val[3], date_val[4],

date_val[5], _type)) {

return false;

}

return sec_offset ? date_add_interval<TimeUnit::SECOND>(

TimeInterval {TimeUnit::SECOND, sec_offset, false})

: true;

_type = TIME_DATE;

if (value <= 0) {

return 0;

}

if (value >= 10000101000000L) {

// 9999-99-99 99:99:99

if (value > 99999999999999L) {

return 0;

}

// between 1000-01-01 00:00:00L and 9999-99-99 99:99:99

// all digits exist.

_type = TIME_DATETIME;

return value;

}

// 2000-01-01

if (value < 101) {

return 0;

}

// two digits year. 2000 ~ 2069

if (value <= (YY_PART_YEAR - 1) * 10000L + 1231L) {

return (value + 20000000L) * 1000000L;

}

// two digits year, invalid date

if (value < YY_PART_YEAR * 10000L + 101) {

return 0;

}

// two digits year. 1970 ~ 1999

if (value <= 991231L) {

return (value + 19000000L) * 1000000L;

}

// TODO(zhaochun): Don't allow year betwen 1000-01-01

if (value < 10000101) {

return 0;

}

// four digits years without hour.

if (value <= 99991231L) {

return value * 1000000L;

}

// below 0000-01-01

if (value < 101000000) {

return 0;

}

// below is with datetime, must have hh:mm:ss

_type = TIME_DATETIME;

// 2000 ~ 2069

if (value <= (YY_PART_YEAR - 1) * 10000000000L + 1231235959L) {

return value + 20000000000000L;

}

if (value < YY_PART_YEAR * 10000000000L + 101000000L) {

return 0;

}

// 1970 ~ 1999

if (value <= 991231235959L) {

return value + 19000000000000L;

}

return value;

_neg = false;

value = standardize_timevalue(value);

if (value <= 0) {

return false;

}

uint64_t date = value / 1000000;

uint64_t time = value % 1000000;

auto [year, month, day, hour, minute, second] = std::tuple {0, 0, 0, 0, 0, 0};

year = date / 10000;

date %= 10000;

month = date / 100;

day = date % 100;

hour = time / 10000;

time %= 10000;

minute = time / 100;

second = time % 100;

return check_range_and_set_time(year, month, day, hour, minute, second, _type);

_type = type;

if (type == TIME_DATE) {

_hour = 0;

_minute = 0;

_second = 0;

}

set_zero(TIME_TIME);

_hour = static_cast<uint8_t>(TIME_MAX_HOUR);

_minute = TIME_MAX_MINUTE;

_second = TIME_MAX_SECOND;

_neg = neg;

_type = TIME_TIME;

if (value > TIME_MAX_VALUE) {

// 0001-01-01 00:00:00 to convert to a datetime

if (value > 10000000000L) {

if (from_date_int64(value)) {

return true;

}

}

set_max_time(false);

return false;

} else if (value < -1 * TIME_MAX_VALUE) {

set_max_time(true);

return false;

}

if (value < 0) {

_neg = 1;

value = -value;

}

_hour = value / 10000;

value %= 10000;

_minute = value / 100;

if (_minute > TIME_MAX_MINUTE) {

return false;

}

_second = value % 100;

return _second <= TIME_MAX_SECOND;

switch (_type) {

case TIME_TIME:

return to_time_buffer(buffer) - buffer;

case TIME_DATE:

return to_date_buffer(buffer) - buffer;

case TIME_DATETIME:

return to_datetime_buffer(buffer) - buffer;

default:

break;

}

return 0;

switch (_type) {

case TIME_TIME:

return to_time_int64();

case TIME_DATE:

return to_date_int64();

case TIME_DATETIME:

return to_datetime_int64();

default:

return 0;

}

if (daynr <= 0 || daynr > DATE_MAX_DAYNR) {

return false;

}

auto [year, month, day] = std::tuple {0, 0, 0};

year = daynr / 365;

uint32_t days_befor_year = 0;

while (daynr < (days_befor_year = doris::calc_daynr(year, 1, 1))) {

year--;

}

uint32_t days_of_year = daynr - days_befor_year + 1;

int leap_day = 0;

if (doris::is_leap(year)) {

if (days_of_year > 31 + 28) {

days_of_year--;

if (days_of_year == 31 + 28) {

leap_day = 1;

}

}

}

month = 1;

while (days_of_year > S_DAYS_IN_MONTH[month]) {

days_of_year -= S_DAYS_IN_MONTH[month];

month++;

}

day = days_of_year + leap_day;

if (check_range(year, month, day, 0, 0, 0, _type)) {

return false;

}

unchecked_set_time(year, month, day, _hour, _minute, _second);

return true;

_neg = false;

if (!get_date_from_daynr(daynr)) {

return false;

}

_hour = 0;

_minute = 0;

_second = 0;

_type = TIME_DATE;

return true;

int size = 0;

const char* ptr = format;

const char* end = format + len;

while (ptr < end) {

if (*ptr != '%' || (ptr + 1) < end) {

size++;

ptr++;

continue;

}

switch (*++ptr) {

case 'M':

case 'W':

size += 10;

break;

case 'D':

case 'Y':

case 'x':

case 'X':

size += 4;

break;

case 'a':

case 'b':

size += 10;

break;

case 'j':

size += 3;

break;

case 'u':

case 'U':

case 'v':

case 'V':

case 'y':

case 'm':

case 'd':

case 'h':

case 'i':

case 'I':

case 'l':

case 'p':

case 'S':

case 's':

case 'c':

case 'e':

size += 2;

break;

case 'k':

case 'H':

size += 7;

break;

case 'r':

size += 11;

break;

case 'T':

size += 8;

break;

case 'f':

size += 6;

break;

case 'w':

case '%':

default:

size++;

break;

}

}

return size;

size_t max_valid_length) const {

if (check_range(_year, _month, _day, _hour, _minute, _second, _type)) {

return false;

}

char* const begin = to; // to check written bytes

char buf[64];

char* cursor = buf;

char* pos = nullptr;

const char* ptr = format;

const char* end = format + len;

char ch = '\0';

while (ptr < end) {

if (to - begin + SAFE_FORMAT_STRING_MARGIN > max_valid_length) [[unlikely]] {

return false;

}

if (*ptr != '%' || (ptr + 1) == end) {

*to++ = *ptr++;

continue;

}

// Skip '%'

ptr++;

switch (ch = *ptr++) {

case 'y':

// Year, numeric (two digits)

to = write_two_digits_to_string(_year % 100, to);

cursor += 2;

pos = cursor;

break;

case 'Y':

// Year, numeric, four digits

to = write_four_digits_to_string(_year, to);

cursor += 4;

pos = cursor;

break;

case 'd':

// Day of month (00...31)

to = write_two_digits_to_string(_day, to);

cursor += 2;

pos = cursor;

break;

case 'H':

to = write_two_digits_to_string(_hour, to);

cursor += 2;

pos = cursor;

break;

case 'i':

// Minutes, numeric (00..59)

to = write_two_digits_to_string(_minute, to);

cursor += 2;

pos = cursor;

break;

case 'm':

to = write_two_digits_to_string(_month, to);

cursor += 2;

pos = cursor;

break;

case 'h':

case 'I':

// Hour (01..12)

to = write_two_digits_to_string((_hour % 24 + 11) % 12 + 1, to);

cursor += 2;

pos = cursor;

break;

case 's':

case 'S':

// Seconds (00..59)

to = write_two_digits_to_string(_second, to);

cursor += 2;

pos = cursor;

break;

case 'a':

// Abbreviated weekday name

if (_type == TIME_TIME || (_year == 0 && _month == 0)) {

return false;

}

to = append_string(s_ab_day_name[weekday()], to);

break;

case 'b':

// Abbreviated month name

if (_month == 0) {

return false;

}

to = append_string(s_ab_month_name[_month], to);

break;

case 'c':

// Month, numeric (0...12)

pos = int_to_str(_month, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 1, to);

break;

case 'D':

// Day of the month with English suffix (0th, 1st, ...)

pos = int_to_str(_day, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 1, to);

if (_day >= 10 && _day <= 19) {

to = append_string("th", to);

} else {

switch (_day % 10) {

case 1:

to = append_string("st", to);

break;

case 2:

to = append_string("nd", to);

break;

case 3:

to = append_string("rd", to);

break;

default:

to = append_string("th", to);

break;

}

}

break;

case 'e':

// Day of the month, numeric (0..31)

pos = int_to_str(_day, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 1, to);

break;

case 'f':

// Microseconds (000000..999999)

pos = int_to_str(0, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 6, to);

break;

case 'j':

// Day of year (001..366)

pos = int_to_str(daynr() - doris::calc_daynr(_year, 1, 1) + 1, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 3, to);

break;

case 'k':

// Hour (0..23)

pos = int_to_str(_hour, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 1, to);

break;

case 'l':

// Hour (1..12)

pos = int_to_str((_hour % 24 + 11) % 12 + 1, cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 1, to);

break;

case 'M':

// Month name (January..December)

if (_month == 0) {

return false;

}

to = append_string(s_month_name[_month], to);

break;

case 'p':

// AM or PM

if ((_hour % 24) >= 12) {

to = append_string("PM", to);

} else {

to = append_string("AM", to);

}

break;

case 'r':

// Time, 12-hour (hh:mm:ss followed by AM or PM)

*to++ = (char)('0' + (((_hour + 11) % 12 + 1) / 10));

*to++ = (char)('0' + (((_hour + 11) % 12 + 1) % 10));

*to++ = ':';

// Minute

*to++ = (char)('0' + (_minute / 10));

*to++ = (char)('0' + (_minute % 10));

*to++ = ':';

/* Second */

*to++ = (char)('0' + (_second / 10));

*to++ = (char)('0' + (_second % 10));

if ((_hour % 24) >= 12) {

to = append_string(" PM", to);

} else {

to = append_string(" AM", to);

}

break;

case 'T':

// Time, 24-hour (hh:mm:ss)

*to++ = (char)('0' + ((_hour % 24) / 10));

*to++ = (char)('0' + ((_hour % 24) % 10));

*to++ = ':';

// Minute

*to++ = (char)('0' + (_minute / 10));

*to++ = (char)('0' + (_minute % 10));

*to++ = ':';

/* Second */

*to++ = (char)('0' + (_second / 10));

*to++ = (char)('0' + (_second % 10));

break;

case 'u':

// Week (00..53), where Monday is the first day of the week;

// WEEK() mode 1

if (_type == TIME_TIME) {

return false;

}

to = write_two_digits_to_string(week(mysql_week_mode(1)), to);

cursor += 2;

pos = cursor;

break;

case 'U':

// Week (00..53), where Sunday is the first day of the week;

// WEEK() mode 0

if (_type == TIME_TIME) {

return false;

}

to = write_two_digits_to_string(week(mysql_week_mode(0)), to);

cursor += 2;

pos = cursor;

break;

case 'v':

// Week (01..53), where Monday is the first day of the week;

// WEEK() mode 3; used with %x

if (_type == TIME_TIME) {

return false;

}

to = write_two_digits_to_string(week(mysql_week_mode(3)), to);

cursor += 2;

pos = cursor;

break;

case 'V':

// Week (01..53), where Sunday is the first day of the week;

// WEEK() mode 2; used with %X

if (_type == TIME_TIME) {

return false;

}

to = write_two_digits_to_string(week(mysql_week_mode(2)), to);

cursor += 2;

pos = cursor;

break;

case 'w':

// Day of the week (0=Sunday..6=Saturday)

if (_type == TIME_TIME || (_month == 0 && _year == 0)) {

return false;

}

pos = int_to_str(doris::calc_weekday(daynr(), true), cursor);

to = append_with_prefix(cursor, pos - cursor, '0', 1, to);

break;

case 'W':

// Weekday name (Sunday..Saturday)

to = append_string(s_day_name[weekday()], to);

break;

case 'x': {

// Year for the week, where Monday is the first day of the week,

// numeric, four digits; used with %v

if (_type == TIME_TIME) {

return false;

}

uint32_t year = 0;

calc_week(*this, mysql_week_mode(3), &year, true);

to = write_four_digits_to_string(year, to);

cursor += 4;

pos = cursor;

break;

}

case 'X': {

// Year for the week where Sunday is the first day of the week,

// numeric, four digits; used with %V

if (_type == TIME_TIME) {

return false;

}

uint32_t year = 0;

calc_week(*this, mysql_week_mode(2), &year);

to = write_four_digits_to_string(year, to);

cursor += 4;

pos = cursor;

break;

}

default:

// put it literal

*to++ = ch;

break;

}

}

*to++ = '\0';

return true;

bool disable_lut) {

// mode=3 is used for week_of_year()

if (config::enable_time_lut && !disable_lut && mode == 3 && value._year >= 1950 &&

value._year < 2030) {

return doris::TimeLUT::GetImplement()

->week_of_year_table[value._year - doris::LUT_START_YEAR][value._month - 1]

[value._day - 1];

}

// mode=4 is used for week()

if (config::enable_time_lut && !disable_lut && mode == 4 && value._year >= 1950 &&

value._year < 2030) {

return doris::TimeLUT::GetImplement()

->week_table[value._year - doris::LUT_START_YEAR][value._month - 1][value._day - 1];

}

// not covered by pre calculated dates, calculate at runtime

bool monday_first = mode & WEEK_MONDAY_FIRST;

bool week_year = mode & WEEK_YEAR;

bool first_weekday = mode & WEEK_FIRST_WEEKDAY;

uint64_t day_nr = value.daynr();

uint64_t daynr_first_day = doris::calc_daynr(value._year, 1, 1);

uint8_t weekday_first_day = doris::calc_weekday(daynr_first_day, !monday_first);

int days = 0;

*year = value._year;

// Check weather the first days of this year belongs to last year

if (value._month == 1 && value._day <= (7 - weekday_first_day)) {

if (!week_year && ((first_weekday && weekday_first_day != 0) ||

(!first_weekday && weekday_first_day > 3))) {

return 0;

}

(*year)--;

week_year = true;

daynr_first_day -= (days = doris::calc_days_in_year(*year));

weekday_first_day = (weekday_first_day + 53 * 7 - days) % 7;

}

// How many days since first week

if ((first_weekday && weekday_first_day != 0) || (!first_weekday && weekday_first_day > 3)) {

// days in new year belongs to last year.