diff options
Diffstat (limited to 'sql-common/my_time.c')
| -rw-r--r-- | sql-common/my_time.c | 771 |
1 files changed, 611 insertions, 160 deletions
diff --git a/sql-common/my_time.c b/sql-common/my_time.c index c4731d6b601..2aa657ca14e 100644 --- a/sql-common/my_time.c +++ b/sql-common/my_time.c @@ -58,6 +58,18 @@ uint calc_days_in_year(uint year) 366 : 365); } + +#ifndef DBUG_OFF + +static const ulonglong C_KNOWN_FLAGS= C_TIME_NO_ZERO_IN_DATE | + C_TIME_NO_ZERO_DATE | + C_TIME_INVALID_DATES; + +#define C_FLAGS_OK(flags) (((flags) & ~C_KNOWN_FLAGS) == 0) + +#endif + + /** @brief Check datetime value for validity according to flags. @@ -82,13 +94,14 @@ uint calc_days_in_year(uint year) my_bool check_date(const MYSQL_TIME *ltime, my_bool not_zero_date, ulonglong flags, int *was_cut) { + DBUG_ASSERT(C_FLAGS_OK(flags)); if (ltime->time_type == MYSQL_TIMESTAMP_TIME) return FALSE; if (not_zero_date) { - if (((flags & TIME_NO_ZERO_IN_DATE) && + if (((flags & C_TIME_NO_ZERO_IN_DATE) && (ltime->month == 0 || ltime->day == 0)) || ltime->neg || - (!(flags & TIME_INVALID_DATES) && + (!(flags & C_TIME_INVALID_DATES) && ltime->month && ltime->day > days_in_month[ltime->month-1] && (ltime->month != 2 || calc_days_in_year(ltime->year) != 366 || ltime->day != 29))) @@ -97,12 +110,13 @@ my_bool check_date(const MYSQL_TIME *ltime, my_bool not_zero_date, return TRUE; } } - else if (flags & TIME_NO_ZERO_DATE) + else if (flags & C_TIME_NO_ZERO_DATE) { /* We don't set *was_cut here to signal that the problem was a zero date and not an invalid date */ + *was_cut|= MYSQL_TIME_WARN_ZERO_DATE; return TRUE; } return FALSE; @@ -145,7 +159,8 @@ static int get_punct(const char **str, const char *end) return 1; } -static int get_date_time_separator(uint *number_of_fields, ulonglong flags, +static int get_date_time_separator(uint *number_of_fields, + my_bool punct_is_date_time_separator, const char **str, const char *end) { const char *s= *str; @@ -164,11 +179,11 @@ static int get_date_time_separator(uint *number_of_fields, ulonglong flags, but cast("11:11:11.12.12.12" as time) should give 11:11:11.12 that is, a punctuation character can be accepted as a date/time separator - only if TIME_DATETIME_ONLY (see str_to_time) is not set. + only if "punct_is_date_time_separator" is set. */ if (my_ispunct(&my_charset_latin1, *s)) { - if (flags & TIME_DATETIME_ONLY) + if (!punct_is_date_time_separator) { /* see above, returning 1 is not enough, we need hard abort here */ *number_of_fields= 0; @@ -241,25 +256,220 @@ static void get_microseconds(ulong *val, MYSQL_TIME_STATUS *status, *val= (ulong) (tmp * log_10_int[6 - (*str - start)]); else *val= tmp; + if (str[0] < end && my_isdigit(&my_charset_latin1, str[0][0])) + { + /* + We don't need the exact nanoseconds value. + Knowing the first digit is enough for rounding. + */ + status->nanoseconds= 100 * (uint)(str[0][0] - '0'); + } if (skip_digits(str, end)) status->warnings|= MYSQL_TIME_NOTE_TRUNCATED; } +static int check_time_range_internal(MYSQL_TIME *ltime, + ulong max_hour, ulong err_hour, + uint dec, int *warning); + +int check_time_range(MYSQL_TIME *ltime, uint dec, int *warning) +{ + return check_time_range_internal(ltime, TIME_MAX_HOUR, UINT_MAX32, + dec, warning); +} + + +static my_bool +set_neg(my_bool neg, MYSQL_TIME_STATUS *st, MYSQL_TIME *ltime) +{ + if ((ltime->neg= neg) && ltime->time_type != MYSQL_TIMESTAMP_TIME) + { + st->warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE; + return TRUE; + } + return FALSE; +} + + + /* Remove trailing spaces and garbage */ +static my_bool get_suffix(const char *str, size_t length, size_t *new_length) +{ + /* + QQ: perhaps 'T' should be considered as a date/time delimiter only + if it's followed by a digit. Learn ISO 8601 details. + */ + my_bool garbage= FALSE; + for ( ; length > 0 ; length--) + { + char ch= str[length - 1]; + if (my_isdigit(&my_charset_latin1, ch) || + my_ispunct(&my_charset_latin1, ch)) + break; + if (my_isspace(&my_charset_latin1, ch)) + continue; + if (ch == 'T') + { + /* 'T' has a meaning only after a digit. Otherwise it's a garbage */ + if (length >= 2 && my_isdigit(&my_charset_latin1, str[length - 2])) + break; + } + garbage= TRUE; + } + *new_length= length; + return garbage; +} + + +static size_t get_prefix(const char *str, size_t length, const char **endptr) +{ + const char *str0= str, *end= str + length; + for (; str < end && my_isspace(&my_charset_latin1, *str) ; str++) + { } + *endptr= str; + return str - str0; +} + + +static size_t get_sign(my_bool *neg, const char *str, size_t length, + const char **endptr) +{ + const char *str0= str; + if (length) + { + if ((*neg= (*str == '-')) || (*str == '+')) + str++; + } + else + *neg= FALSE; + *endptr= str; + return str - str0; +} + + +static my_bool find_body(my_bool *neg, const char *str, size_t length, + MYSQL_TIME *to, int *warn, + const char **new_str, size_t *new_length) +{ + size_t sign_length; + *warn= 0; + length-= get_prefix(str, length, &str); + sign_length= get_sign(neg, str, length, &str); + length-= sign_length; + /* There can be a space after a sign again: '- 10:20:30' or '- 1 10:20:30' */ + length-= get_prefix(str, length, &str); + if (get_suffix(str, length, &length)) + *warn|= MYSQL_TIME_WARN_TRUNCATED; + *new_str= str; + *new_length= length; + if (!length || !my_isdigit(&my_charset_latin1, *str)) + { + *warn|= MYSQL_TIME_WARN_EDOM; + set_zero_time(to, MYSQL_TIMESTAMP_ERROR); + return TRUE; + } + return FALSE; +} + + +typedef struct +{ + uint count_punct; + uint count_colon; + uint count_iso_date_time_separator; +} MYSQL_TIME_USED_CHAR_STATISTICS; + + +static void +mysql_time_used_char_statistics_init(MYSQL_TIME_USED_CHAR_STATISTICS *to, + const char *str, const char *end) +{ + const char *s; + bzero((void *) to, sizeof(MYSQL_TIME_USED_CHAR_STATISTICS)); + for (s= str; s < end; s++) + { + if (my_ispunct(&my_charset_latin1, *s)) + to->count_punct++; + if (*s == ':') + to->count_colon++; + if (*s == 'T') + to->count_iso_date_time_separator++; + } +} + + +static my_bool +is_datetime_body_candidate(const char *str, size_t length, + my_bool allow_dates_delimited, + my_bool allow_dates_numeric) +{ + static uint min_date_length= 5; /* '1-1-1' -> '0001-01-01' */ + uint pos, count_punct= 0; + uint date_time_separator_length= MY_TEST(!allow_dates_delimited); + if (length >= 12) + return TRUE; + /* + The shortest possible DATE is '1-1-1', which is 5 characters. + To make a full datetime it should be at least followed by a space or a 'T'. + To make a date it should be just not less that 5 characters. + */ + if (length < min_date_length + date_time_separator_length && + !allow_dates_numeric) + return FALSE; + for (pos= 0; pos < length; pos++) + { + if (str[pos] == 'T') /* Date/time separator */ + return TRUE; + if (str[pos] == ' ') + { + /* + We found a space. If can be a DATE/TIME separator: + TIME('1-1-1 1:1:1.0) -> '0001-01-01 01:01:01.0' + + But it can be also a DAY/TIME separator: + TIME('1 11') -> 35:00:00 = 1 day 11 hours + TIME('1 111') -> 135:00:00 = 1 day 111 hours + TIME('11 11') -> 275:00:00 = 11 days 11 hours + TIME('111 11') -> 838:59:59 = 111 days 11 hours with overflow + TIME('1111 11') -> 838:59:59 = 1111 days 11 hours with overflow + */ + return count_punct > 0; /* Can be a DATE if already had separators*/ + } + if (my_ispunct(&my_charset_latin1, str[pos])) + { + if (allow_dates_delimited && str[pos] != ':') + return TRUE; + count_punct++; + } + } + return allow_dates_numeric && count_punct == 0; +} + + +static my_bool +str_to_DDhhmmssff_internal(my_bool neg, const char *str, size_t length, + MYSQL_TIME *l_time, + ulong max_hour, ulong err_hour, + MYSQL_TIME_STATUS *status, + const char **endptr); + + /* Convert a timestamp string to a MYSQL_TIME value. SYNOPSIS - str_to_datetime() + str_to_datetime_or_date_body() str String to parse length Length of string l_time Date is stored here flags Bitmap of following items - TIME_FUZZY_DATE TIME_DATETIME_ONLY Set if we only allow full datetimes. TIME_NO_ZERO_IN_DATE Don't allow partial dates TIME_NO_ZERO_DATE Don't allow 0000-00-00 date TIME_INVALID_DATES Allow 2000-02-31 + punct_is_date_time_separator + Allow punctuation as a date/time separator, + or return a hard error. status Conversion status @@ -292,32 +502,22 @@ static void get_microseconds(ulong *val, MYSQL_TIME_STATUS *status, #define MAX_DATE_PARTS 8 -my_bool -str_to_datetime(const char *str, size_t length, MYSQL_TIME *l_time, - ulonglong flags, MYSQL_TIME_STATUS *status) +static my_bool +str_to_datetime_or_date_body(const char *str, size_t length, MYSQL_TIME *l_time, + ulonglong flags, + my_bool punct_is_date_time_separator, + MYSQL_TIME_STATUS *status, + uint *number_of_fields, + const char **endptr) { const char *end=str+length, *pos; - uint number_of_fields= 0, digits, year_length, not_zero_date; - DBUG_ENTER("str_to_datetime"); + uint digits, year_length, not_zero_date; + int warn= 0; + DBUG_ENTER("str_to_datetime_or_date_body"); + DBUG_ASSERT(C_FLAGS_OK(flags)); bzero(l_time, sizeof(*l_time)); - - if (flags & TIME_TIME_ONLY) - { - my_bool ret= str_to_time(str, length, l_time, flags, status); - DBUG_RETURN(ret); - } - - my_time_status_init(status); - - /* Skip space at start */ - for (; str != end && my_isspace(&my_charset_latin1, *str) ; str++) - ; - if (str == end || ! my_isdigit(&my_charset_latin1, *str)) - { - status->warnings= MYSQL_TIME_WARN_TRUNCATED; - l_time->time_type= MYSQL_TIMESTAMP_NONE; - DBUG_RETURN(1); - } + *number_of_fields= 0; + *endptr= str; /* Calculate number of digits in first part. @@ -345,49 +545,53 @@ str_to_datetime(const char *str, size_t length, MYSQL_TIME *l_time, (only numbers like [YY]YYMMDD[T][hhmmss[.uuuuuu]]) */ year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2; - if (get_digits(&l_time->year, &number_of_fields, &str, end, year_length) - || get_digits(&l_time->month, &number_of_fields, &str, end, 2) - || get_digits(&l_time->day, &number_of_fields, &str, end, 2) + if (get_digits(&l_time->year, number_of_fields, &str, end, year_length) + || get_digits(&l_time->month, number_of_fields, &str, end, 2) + || get_digits(&l_time->day, number_of_fields, &str, end, 2) || get_maybe_T(&str, end) - || get_digits(&l_time->hour, &number_of_fields, &str, end, 2) - || get_digits(&l_time->minute, &number_of_fields, &str, end, 2) - || get_digits(&l_time->second, &number_of_fields, &str, end, 2)) - status->warnings|= MYSQL_TIME_WARN_TRUNCATED; + || get_digits(&l_time->hour, number_of_fields, &str, end, 2) + || get_digits(&l_time->minute, number_of_fields, &str, end, 2) + || get_digits(&l_time->second, number_of_fields, &str, end, 2)) + warn|= MYSQL_TIME_WARN_TRUNCATED; } else { const char *start= str; - if (get_number(&l_time->year, &number_of_fields, &str, end)) - status->warnings|= MYSQL_TIME_WARN_TRUNCATED; + if (get_number(&l_time->year, number_of_fields, &str, end)) + warn|= MYSQL_TIME_WARN_TRUNCATED; year_length= (uint)(str - start); - if (!status->warnings && + if (!warn && (get_punct(&str, end) - || get_number(&l_time->month, &number_of_fields, &str, end) + || get_number(&l_time->month, number_of_fields, &str, end) || get_punct(&str, end) - || get_number(&l_time->day, &number_of_fields, &str, end) - || get_date_time_separator(&number_of_fields, flags, &str, end) - || get_number(&l_time->hour, &number_of_fields, &str, end) + || get_number(&l_time->day, number_of_fields, &str, end) + || get_date_time_separator(number_of_fields, + punct_is_date_time_separator, &str, end) + || get_number(&l_time->hour, number_of_fields, &str, end) || get_punct(&str, end) - || get_number(&l_time->minute, &number_of_fields, &str, end) + || get_number(&l_time->minute, number_of_fields, &str, end) || get_punct(&str, end) - || get_number(&l_time->second, &number_of_fields, &str, end))) - status->warnings|= MYSQL_TIME_WARN_TRUNCATED; + || get_number(&l_time->second, number_of_fields, &str, end))) + warn|= MYSQL_TIME_WARN_TRUNCATED; } + status->warnings|= warn; + *endptr= str; /* we're ok if date part is correct. even if the rest is truncated */ - if (number_of_fields < 3) + if (*number_of_fields < 3) { l_time->time_type= MYSQL_TIMESTAMP_NONE; status->warnings|= MYSQL_TIME_WARN_TRUNCATED; DBUG_RETURN(TRUE); } - if (!status->warnings && str < end && *str == '.') + if (!warn && str < end && *str == '.') { str++; get_microseconds(&l_time->second_part, status, - &number_of_fields, &str, end); + number_of_fields, &str, end); + *endptr= str; } not_zero_date = l_time->year || l_time->month || l_time->day || @@ -407,23 +611,16 @@ str_to_datetime(const char *str, size_t length, MYSQL_TIME *l_time, if (check_date(l_time, not_zero_date, flags, &status->warnings)) goto err; - l_time->time_type= (number_of_fields <= 3 ? + l_time->time_type= (*number_of_fields <= 3 ? MYSQL_TIMESTAMP_DATE : MYSQL_TIMESTAMP_DATETIME); - for (; str != end ; str++) - { - if (!my_isspace(&my_charset_latin1,*str)) - { - status->warnings= MYSQL_TIME_WARN_TRUNCATED; - break; - } - } + if (str != end) + status->warnings= MYSQL_TIME_WARN_TRUNCATED; DBUG_RETURN(FALSE); err: - bzero((char*) l_time, sizeof(*l_time)); - l_time->time_type= MYSQL_TIMESTAMP_ERROR; + set_zero_time(l_time, MYSQL_TIMESTAMP_ERROR); DBUG_RETURN(TRUE); } @@ -432,7 +629,7 @@ err: Convert a time string to a MYSQL_TIME struct. SYNOPSIS - str_to_time() + str_to_datetime_or_date_or_time_body() str A string in full TIMESTAMP format or [-] DAYS [H]H:MM:SS, [H]H:MM:SS, [M]M:SS, [H]HMMSS, [M]MSS or [S]S @@ -457,45 +654,280 @@ err: TRUE on error */ -my_bool str_to_time(const char *str, size_t length, MYSQL_TIME *l_time, - ulonglong fuzzydate, MYSQL_TIME_STATUS *status) +static my_bool +str_to_datetime_or_date_or_time_body(const char *str, size_t length, + MYSQL_TIME *l_time, + ulonglong fuzzydate, + MYSQL_TIME_STATUS *status, + ulong time_max_hour, + ulong time_err_hour, + my_bool allow_dates_delimited, + my_bool allow_dates_numeric) { - ulong date[5]; - ulonglong value; - const char *end=str+length, *end_of_days; - my_bool found_days,found_hours, neg= 0; - uint UNINIT_VAR(state); - - my_time_status_init(status); - for (; str != end && my_isspace(&my_charset_latin1,*str) ; str++) - length--; - if (str != end && *str == '-') - { - neg=1; - str++; - length--; - } - if (str == end) - { - status->warnings|= MYSQL_TIME_WARN_TRUNCATED; - goto err; - } + const char *endptr; + DBUG_ASSERT(C_FLAGS_OK(fuzzydate)); /* Check first if this is a full TIMESTAMP */ - if (length >= 12) + if (is_datetime_body_candidate(str, length, + allow_dates_delimited, + allow_dates_numeric)) { /* Probably full timestamp */ - (void) str_to_datetime(str, length, l_time, - (fuzzydate & ~TIME_TIME_ONLY) | TIME_DATETIME_ONLY, - status); - if (l_time->time_type >= MYSQL_TIMESTAMP_ERROR) - return l_time->time_type == MYSQL_TIMESTAMP_ERROR; + int warn_copy= status->warnings; /* could already be set by find_body() */ + uint number_of_fields; + (void) str_to_datetime_or_date_body(str, length, l_time, fuzzydate, + FALSE, status, + &number_of_fields, &endptr); + DBUG_ASSERT(endptr >= str); + DBUG_ASSERT(endptr <= str + length); + switch (l_time->time_type) { + case MYSQL_TIMESTAMP_DATETIME: + return FALSE; + case MYSQL_TIMESTAMP_DATE: + { + /* + Successfully parsed as DATE, but it can also be a TIME: + '24:02:03' - continue and parse as TIME + '24:02:03 garbage /////' - continue and parse as TIME + '24:02:03T' - return DATE + '24-02-03' - return DATE + '24/02/03' - return DATE + '11111' - return DATE + */ + MYSQL_TIME_USED_CHAR_STATISTICS used_chars; + mysql_time_used_char_statistics_init(&used_chars, str, endptr); + if (used_chars.count_iso_date_time_separator || !used_chars.count_colon) + return FALSE; + } + break; + case MYSQL_TIMESTAMP_ERROR: + { + MYSQL_TIME_USED_CHAR_STATISTICS used_chars; + /* + Check if it parsed as DATETIME but then failed as out of range: + '2011-02-32 8:46:06.23434' - return error + */ + if (number_of_fields > 3) + return TRUE; + /* + Check if it parsed as DATE but then failed as out of range: + '100000:02:03' - continue and parse as TIME + '100000:02:03T' - return error + '100000/02/03' - return error + '100000-02-03' - return error + */ + mysql_time_used_char_statistics_init(&used_chars, str, endptr); + if (used_chars.count_iso_date_time_separator || !used_chars.count_colon) + return TRUE; + } + break; + case MYSQL_TIMESTAMP_NONE: + { + if (allow_dates_numeric && endptr >= str + length) + { + /* + For backward compatibility this parses as DATE and fails: + EXTRACT(DAY FROM '1111') -- return error + EXTRACT(DAY FROM '1') -- return error + */ + MYSQL_TIME_USED_CHAR_STATISTICS used_chars; + mysql_time_used_char_statistics_init(&used_chars, str, endptr); + if (!used_chars.count_iso_date_time_separator && + !used_chars.count_colon && + !used_chars.count_punct) + return TRUE; + } + /* + - '256 10:30:30' - continue and parse as TIME + - '4294967296:59:59.123456456' - continue and parse as TIME + */ + } + break; + case MYSQL_TIMESTAMP_TIME: + DBUG_ASSERT(0); + break; + } + my_time_status_init(status); + status->warnings= warn_copy; + } + + if (!str_to_DDhhmmssff_internal(FALSE, str, length, l_time, + time_max_hour, time_err_hour, + status, &endptr)) + return FALSE; + + set_zero_time(l_time, MYSQL_TIMESTAMP_ERROR); + return TRUE; +} + + +/* + Convert a string with INTERVAL DAY TO SECOND to MYSQL_TIME. + Input format: [-][DD ]hh:mm:ss.ffffff + + If the input string appears to be a DATETIME, error is returned. +*/ +my_bool str_to_DDhhmmssff(const char *str, size_t length, MYSQL_TIME *ltime, + ulong max_hour, MYSQL_TIME_STATUS *status) +{ + my_bool neg; + const char *endptr; + + my_time_status_init(status); + if (find_body(&neg, str, length, ltime, &status->warnings, &str, &length)) + return TRUE; + + /* Reject anything that might be parsed as a full TIMESTAMP */ + if (is_datetime_body_candidate(str, length, FALSE, FALSE)) + { + uint number_of_fields; + (void) str_to_datetime_or_date_body(str, length, ltime, 0, FALSE, + status, &number_of_fields, &endptr); + if (ltime->time_type > MYSQL_TIMESTAMP_ERROR) + { + status->warnings|= MYSQL_TIME_WARN_TRUNCATED; + ltime->time_type= MYSQL_TIMESTAMP_NONE; + return TRUE; + } my_time_status_init(status); } + /* + Scan DDhhmmssff then reject anything that can remind date/datetime. + For example, in case of '2001-01-01', str_to_DDhhmmssff_internal() + will scan only '2001'. + */ + if (str_to_DDhhmmssff_internal(neg, str, length, ltime, max_hour, + UINT_MAX32, status, &endptr) || + (endptr < str + length && endptr[0] == '-')) + return TRUE; + return FALSE; +} + + +my_bool +str_to_datetime_or_date_or_time(const char *str, size_t length, + MYSQL_TIME *to, ulonglong mode, + MYSQL_TIME_STATUS *status, + ulong time_max_hour, + ulong time_err_hour) +{ + my_bool neg; + DBUG_ASSERT(C_FLAGS_OK(mode)); + my_time_status_init(status); + return + find_body(&neg, str, length, to, &status->warnings, &str, &length) || + str_to_datetime_or_date_or_time_body(str, length, to, mode, status, + time_max_hour, time_err_hour, + FALSE, FALSE) || + set_neg(neg, status, to); +} + + +my_bool +str_to_datetime_or_date_or_interval_hhmmssff(const char *str, size_t length, + MYSQL_TIME *to, ulonglong mode, + MYSQL_TIME_STATUS *status, + ulong time_max_hour, + ulong time_err_hour) +{ + my_bool neg; + DBUG_ASSERT(C_FLAGS_OK(mode)); + my_time_status_init(status); + return + find_body(&neg, str, length, to, &status->warnings, &str, &length) || + str_to_datetime_or_date_or_time_body(str, length, to, mode, status, + time_max_hour, time_err_hour, + TRUE, FALSE) || + set_neg(neg, status, to); +} + + +my_bool +str_to_datetime_or_date_or_interval_day(const char *str, size_t length, + MYSQL_TIME *to, ulonglong mode, + MYSQL_TIME_STATUS *status, + ulong time_max_hour, + ulong time_err_hour) +{ + my_bool neg; + DBUG_ASSERT(C_FLAGS_OK(mode)); + my_time_status_init(status); + /* + For backward compatibility we allow to parse non-delimited + values as DATE rather than as TIME: + EXTRACT(DAY FROM '11111') + */ + return + find_body(&neg, str, length, to, &status->warnings, &str, &length) || + str_to_datetime_or_date_or_time_body(str, length, to, mode, status, + time_max_hour, time_err_hour, + TRUE, TRUE) || + set_neg(neg, status, to); +} + + +my_bool +str_to_datetime_or_date(const char *str, size_t length, MYSQL_TIME *l_time, + ulonglong flags, MYSQL_TIME_STATUS *status) +{ + my_bool neg; + uint number_of_fields; + const char *endptr; + DBUG_ASSERT(C_FLAGS_OK(flags)); + my_time_status_init(status); + return + find_body(&neg, str, length, l_time, &status->warnings, &str, &length) || + str_to_datetime_or_date_body(str, length, l_time, flags, TRUE, + status, &number_of_fields, &endptr) || + set_neg(neg, status, l_time); +} + + + +/** + Convert a string to INTERVAL DAY TO SECOND. + Input format: [DD ]hh:mm:ss.ffffff + + Datetime or date formats are not understood. + + Optional leading spaces and signs must be scanned by the caller. + "str" should point to the first digit. + + @param neg - set the value to be negative + @param str - the input string + @param length - length of "str" + @param[OUT] l_time - write the result here + @param max_hour - if the result hour value appears to be greater than + max_hour, then cut to result to 'max_hour:59:59.999999' + @param err_hour - if the hour appears to be greater than err_hour, + return an error (without cut) + @param status + @param endptr +*/ +static my_bool +str_to_DDhhmmssff_internal(my_bool neg, const char *str, size_t length, + MYSQL_TIME *l_time, + ulong max_hour, ulong err_hour, + MYSQL_TIME_STATUS *status, const char **endptr) +{ + ulong date[5]; + ulonglong value; + const char *end=str + length, *end_of_days; + my_bool found_days, found_hours; + uint UNINIT_VAR(state); + + *endptr= str; l_time->neg= neg; - /* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */ + /* Not a timestamp. Try to get this as a DAYS TO SECOND string */ for (value=0; str != end && my_isdigit(&my_charset_latin1,*str) ; str++) + { value=value*10L + (long) (*str - '0'); + if (value >= 42949672955959ULL) /* i.e. UINT_MAX32 : 59 : 59 */ + { + status->warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE; + goto err; + } + } /* Skip all space after 'days' */ end_of_days= str; @@ -514,6 +946,11 @@ my_bool str_to_time(const char *str, size_t length, MYSQL_TIME *l_time, my_isdigit(&my_charset_latin1, str[1])) { date[0]= 0; /* Assume we found hours */ + if (value >= UINT_MAX32) + { + status->warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE; + goto err; + } date[1]= (ulong) value; state=2; found_hours=1; @@ -523,6 +960,7 @@ my_bool str_to_time(const char *str, size_t length, MYSQL_TIME *l_time, { /* String given as one number; assume HHMMSS format */ date[0]= 0; + DBUG_ASSERT(value <= ((ulonglong) UINT_MAX32) * 10000ULL); date[1]= (ulong) (value/10000); date[2]= (ulong) (value/100 % 100); date[3]= (ulong) (value % 100); @@ -557,7 +995,7 @@ my_bool str_to_time(const char *str, size_t length, MYSQL_TIME *l_time, fractional: /* Get fractional second part */ - if (!status->warnings && str < end && *str == '.') + if (str < end && *str == '.') { uint number_of_fields= 0; str++; @@ -605,6 +1043,11 @@ fractional: goto err; } + if ((ulonglong) date[0] * 24 + date[1] > (ulonglong) UINT_MAX32) + { + status->warnings|= MYSQL_TIME_WARN_OUT_OF_RANGE; + goto err; + } l_time->year= 0; /* For protocol::store_time */ l_time->month= 0; l_time->day= 0; @@ -614,27 +1057,20 @@ fractional: l_time->second_part= date[4]; l_time->time_type= MYSQL_TIMESTAMP_TIME; + *endptr= str; + /* Check if the value is valid and fits into MYSQL_TIME range */ - if (check_time_range(l_time, 6, &status->warnings)) + if (check_time_range_internal(l_time, max_hour, err_hour, + 6, &status->warnings)) return TRUE; /* Check if there is garbage at end of the MYSQL_TIME specification */ if (str != end) - { - do - { - if (!my_isspace(&my_charset_latin1,*str)) - { - status->warnings|= MYSQL_TIME_WARN_TRUNCATED; - break; - } - } while (++str != end); - } + status->warnings|= MYSQL_TIME_WARN_TRUNCATED; return FALSE; err: - bzero((char*) l_time, sizeof(*l_time)); - l_time->time_type= MYSQL_TIMESTAMP_ERROR; + *endptr= str; return TRUE; } @@ -643,8 +1079,11 @@ err: Check 'time' value to lie in the MYSQL_TIME range SYNOPSIS: - check_time_range() + check_time_range_internal() time pointer to MYSQL_TIME value + ulong max_hour - maximum allowed hour value. if the hour is greater, + cut the time value to 'max_hour:59:59.999999' + ulong err_hour - if hour is greater than this value, return an error uint dec warning set MYSQL_TIME_WARN_OUT_OF_RANGE flag if the value is out of range @@ -658,13 +1097,16 @@ err: 1 time value is invalid */ -int check_time_range(struct st_mysql_time *my_time, uint dec, int *warning) +int check_time_range_internal(struct st_mysql_time *my_time, + ulong max_hour, ulong err_hour, + uint dec, int *warning) { - longlong hour; + ulonglong hour; static ulong max_sec_part[TIME_SECOND_PART_DIGITS+1]= {000000, 900000, 990000, 999000, 999900, 999990, 999999}; - if (my_time->minute >= 60 || my_time->second >= 60) + if (my_time->minute >= 60 || my_time->second >= 60 || + my_time->hour > err_hour) { *warning|= MYSQL_TIME_WARN_TRUNCATED; return 1; @@ -675,14 +1117,14 @@ int check_time_range(struct st_mysql_time *my_time, uint dec, int *warning) if (dec == AUTO_SEC_PART_DIGITS) dec= TIME_SECOND_PART_DIGITS; - if (hour <= TIME_MAX_HOUR && - (hour != TIME_MAX_HOUR || my_time->minute != TIME_MAX_MINUTE || + if (hour <= max_hour && + (hour != max_hour || my_time->minute != TIME_MAX_MINUTE || my_time->second != TIME_MAX_SECOND || my_time->second_part <= max_sec_part[dec])) return 0; my_time->day= 0; - my_time->hour= TIME_MAX_HOUR; + my_time->hour= max_hour; my_time->minute= TIME_MAX_MINUTE; my_time->second= TIME_MAX_SECOND; my_time->second_part= max_sec_part[dec]; @@ -1031,6 +1473,46 @@ static char* fmt_number(uint val, char *out, uint digits) } +static int my_mmssff_to_str(const MYSQL_TIME *ltime, char *to, uint fsp) +{ + char *pos= to; + if (fsp == AUTO_SEC_PART_DIGITS) + fsp= ltime->second_part ? TIME_SECOND_PART_DIGITS : 0; + DBUG_ASSERT(fsp <= TIME_SECOND_PART_DIGITS); + pos= fmt_number(ltime->minute, pos, 2); + *pos++= ':'; + pos= fmt_number(ltime->second, pos, 2); + if (fsp) + { + *pos++= '.'; + pos= fmt_number((uint)sec_part_shift(ltime->second_part, fsp), pos, fsp); + } + return (int) (pos - to); +} + + +int my_interval_DDhhmmssff_to_str(const MYSQL_TIME *ltime, char *to, uint fsp) +{ + uint hour= ltime->day * 24 + ltime->hour; + char *pos= to; + DBUG_ASSERT(!ltime->year); + DBUG_ASSERT(!ltime->month); + + if(ltime->neg) + *pos++= '-'; + if (hour >= 24) + { + pos= longlong10_to_str((longlong) hour / 24, pos, 10); + *pos++= ' '; + } + pos= fmt_number(hour % 24, pos, 2); + *pos++= ':'; + pos+= my_mmssff_to_str(ltime, pos, fsp); + *pos= 0; + return (int) (pos-to); +} + + /* Functions to convert time/date/datetime value to a string, using default format. @@ -1048,11 +1530,6 @@ int my_time_to_str(const MYSQL_TIME *l_time, char *to, uint digits) uint hour= day * 24 + l_time->hour; char*pos= to; - if (digits == AUTO_SEC_PART_DIGITS) - digits= l_time->second_part ? TIME_SECOND_PART_DIGITS : 0; - - DBUG_ASSERT(digits <= TIME_SECOND_PART_DIGITS); - if(l_time->neg) *pos++= '-'; @@ -1063,17 +1540,7 @@ int my_time_to_str(const MYSQL_TIME *l_time, char *to, uint digits) pos= fmt_number(hour, pos, 2); *pos++= ':'; - pos= fmt_number(l_time->minute, pos, 2); - *pos++= ':'; - pos= fmt_number(l_time->second, pos, 2); - - if (digits) - { - *pos++= '.'; - pos= fmt_number((uint)sec_part_shift(l_time->second_part, digits), - pos, digits); - } - + pos+= my_mmssff_to_str(l_time, pos, digits); *pos= 0; return (int) (pos-to); } @@ -1095,12 +1562,6 @@ int my_date_to_str(const MYSQL_TIME *l_time, char *to) int my_datetime_to_str(const MYSQL_TIME *l_time, char *to, uint digits) { char *pos= to; - - if (digits == AUTO_SEC_PART_DIGITS) - digits= l_time->second_part ? TIME_SECOND_PART_DIGITS : 0; - - DBUG_ASSERT(digits <= TIME_SECOND_PART_DIGITS); - pos= fmt_number(l_time->year, pos, 4); *pos++='-'; pos= fmt_number(l_time->month, pos, 2); @@ -1109,17 +1570,7 @@ int my_datetime_to_str(const MYSQL_TIME *l_time, char *to, uint digits) *pos++=' '; pos= fmt_number(l_time->hour, pos, 2); *pos++= ':'; - pos= fmt_number(l_time->minute, pos, 2); - *pos++= ':'; - pos= fmt_number(l_time->second, pos, 2); - - if (digits) - { - *pos++='.'; - pos= fmt_number((uint) sec_part_shift(l_time->second_part, digits), pos, - digits); - } - + pos+= my_mmssff_to_str(l_time, pos, digits); *pos= 0; return (int)(pos - to); } @@ -1185,7 +1636,7 @@ int my_timeval_to_str(const struct timeval *tm, char *to, uint dec) representation and form value of DATETIME type as side-effect. SYNOPSIS - number_to_datetime() + number_to_datetime_or_date() nr - datetime value as number time_res - pointer for structure for broken-down representation flags - flags to use in validating date, as in str_to_datetime() @@ -1206,10 +1657,12 @@ int my_timeval_to_str(const struct timeval *tm, char *to, uint dec) Datetime value in YYYYMMDDHHMMSS format. */ -longlong number_to_datetime(longlong nr, ulong sec_part, MYSQL_TIME *time_res, - ulonglong flags, int *was_cut) +longlong number_to_datetime_or_date(longlong nr, ulong sec_part, + MYSQL_TIME *time_res, + ulonglong flags, int *was_cut) { long part1,part2; + DBUG_ASSERT(C_FLAGS_OK(flags)); *was_cut= 0; time_res->time_type=MYSQL_TIMESTAMP_DATE; @@ -1279,8 +1732,8 @@ longlong number_to_datetime(longlong nr, ulong sec_part, MYSQL_TIME *time_res, } /* Don't want to have was_cut get set if NO_ZERO_DATE was violated. */ - if (nr || !(flags & TIME_NO_ZERO_DATE)) - *was_cut= 1; + if (nr || !(flags & C_TIME_NO_ZERO_DATE)) + *was_cut= MYSQL_TIME_WARN_TRUNCATED; return -1; err: @@ -1289,7 +1742,7 @@ longlong number_to_datetime(longlong nr, ulong sec_part, MYSQL_TIME *time_res, enum enum_mysql_timestamp_type save= time_res->time_type; bzero((char*) time_res, sizeof(*time_res)); time_res->time_type= save; /* Restore range */ - *was_cut= 1; /* Found invalid date */ + *was_cut= MYSQL_TIME_WARN_TRUNCATED; /* Found invalid date */ } return -1; } @@ -1310,22 +1763,20 @@ longlong number_to_datetime(longlong nr, ulong sec_part, MYSQL_TIME *time_res, 0 time value is valid, but was possibly truncated -1 time value is invalid */ -int number_to_time(my_bool neg, ulonglong nr, ulong sec_part, - MYSQL_TIME *ltime, int *was_cut) +int number_to_time_only(my_bool neg, ulonglong nr, ulong sec_part, + ulong max_hour, MYSQL_TIME *ltime, int *was_cut) { - if (nr > 9999999 && nr < 99991231235959ULL && neg == 0) - return number_to_datetime(nr, sec_part, ltime, - TIME_INVALID_DATES, was_cut) < 0 ? -1 : 0; - + static const ulonglong TIME_MAX_mmss= TIME_MAX_MINUTE*100 + TIME_MAX_SECOND; + ulonglong time_max_value= max_hour * 10000ULL + TIME_MAX_mmss; *was_cut= 0; ltime->year= ltime->month= ltime->day= 0; ltime->time_type= MYSQL_TIMESTAMP_TIME; ltime->neg= neg; - if (nr > TIME_MAX_VALUE) + if (nr > time_max_value) { - nr= TIME_MAX_VALUE; + nr= time_max_value; sec_part= TIME_MAX_SECOND_PART; *was_cut= MYSQL_TIME_WARN_OUT_OF_RANGE; } |