/* Copyright (c) 2000, 2012, Oracle and/or its affiliates. Copyright (c) 2009, 2020, MariaDB This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; version 2 of the License. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */ /** @file @brief This file defines all time functions @todo Move month and days to language files */ #ifdef USE_PRAGMA_IMPLEMENTATION #pragma implementation // gcc: Class implementation #endif #include "mariadb.h" #include "sql_priv.h" /* It is necessary to include set_var.h instead of item.h because there are dependencies on include order for set_var.h and item.h. This will be resolved later. */ #include "sql_class.h" // set_var.h: THD #include "set_var.h" #include "sql_locale.h" // MY_LOCALE my_locale_en_US #include "strfunc.h" // check_word #include "sql_type_int.h" // Longlong_hybrid #include "sql_time.h" // make_truncated_value_warning, // get_date_from_daynr, // calc_weekday, calc_week, // convert_month_to_period, // convert_period_to_month, // TIME_to_timestamp, // calc_time_diff, // calc_time_from_sec, // get_date_time_format_str #include "tztime.h" // struct Time_zone #include "sql_class.h" // THD #include #include /** Day number for Dec 31st, 9999. */ #define MAX_DAY_NUMBER 3652424L Func_handler_date_add_interval_datetime_arg0_time func_handler_date_add_interval_datetime_arg0_time; Func_handler_date_add_interval_datetime func_handler_date_add_interval_datetime; Func_handler_date_add_interval_date func_handler_date_add_interval_date; Func_handler_date_add_interval_time func_handler_date_add_interval_time; Func_handler_date_add_interval_string func_handler_date_add_interval_string; Func_handler_add_time_datetime func_handler_add_time_datetime_add(1); Func_handler_add_time_datetime func_handler_add_time_datetime_sub(-1); Func_handler_add_time_time func_handler_add_time_time_add(1); Func_handler_add_time_time func_handler_add_time_time_sub(-1); Func_handler_add_time_string func_handler_add_time_string_add(1); Func_handler_add_time_string func_handler_add_time_string_sub(-1); Func_handler_str_to_date_datetime_sec func_handler_str_to_date_datetime_sec; Func_handler_str_to_date_datetime_usec func_handler_str_to_date_datetime_usec; Func_handler_str_to_date_date func_handler_str_to_date_date; Func_handler_str_to_date_time_sec func_handler_str_to_date_time_sec; Func_handler_str_to_date_time_usec func_handler_str_to_date_time_usec; /* Date formats corresponding to compound %r and %T conversion specifiers Note: We should init at least first element of "positions" array (first member) or hpux11 compiler will die horribly. */ static DATE_TIME_FORMAT time_ampm_format= {{0}, '\0', 0, {(char *)"%I:%i:%S %p", 11}}; static DATE_TIME_FORMAT time_24hrs_format= {{0}, '\0', 0, {(char *)"%H:%i:%S", 8}}; /** Extract datetime value to MYSQL_TIME struct from string value according to format string. @param format date/time format specification @param val String to decode @param length Length of string @param l_time Store result here @param cached_timestamp_type It uses to get an appropriate warning in the case when the value is truncated. @param sub_pattern_end if non-zero then we are parsing string which should correspond compound specifier (like %T or %r) and this parameter is pointer to place where pointer to end of string matching this specifier should be stored. @note Possibility to parse strings matching to patterns equivalent to compound specifiers is mainly intended for use from inside of this function in order to understand %T and %r conversion specifiers, so number of conversion specifiers that can be used in such sub-patterns is limited. Also most of checks are skipped in this case. @note If one adds new format specifiers to this function he should also consider adding them to get_date_time_result_type() function. @retval 0 ok @retval 1 error */ static bool extract_date_time(THD *thd, DATE_TIME_FORMAT *format, const char *val, uint length, MYSQL_TIME *l_time, timestamp_type cached_timestamp_type, const char **sub_pattern_end, const char *date_time_type, date_conv_mode_t fuzzydate) { int weekday= 0, yearday= 0, daypart= 0; int week_number= -1; int error= 0; int strict_week_number_year= -1; int frac_part; bool usa_time= 0; bool UNINIT_VAR(sunday_first_n_first_week_non_iso); bool UNINIT_VAR(strict_week_number); bool UNINIT_VAR(strict_week_number_year_type); const char *val_begin= val; const char *val_end= val + length; const char *ptr= format->format.str; const char *end= ptr + format->format.length; CHARSET_INFO *cs= &my_charset_bin; DBUG_ENTER("extract_date_time"); if (!sub_pattern_end) bzero((char*) l_time, sizeof(*l_time)); l_time->time_type= cached_timestamp_type; for (; ptr != end && val != val_end; ptr++) { /* Skip pre-space between each argument */ if ((val+= cs->scan(val, val_end, MY_SEQ_SPACES)) >= val_end) break; if (*ptr == '%' && ptr+1 != end) { int val_len; char *tmp; error= 0; val_len= (uint) (val_end - val); switch (*++ptr) { /* Year */ case 'Y': tmp= (char*) val + MY_MIN(4, val_len); l_time->year= (int) my_strtoll10(val, &tmp, &error); if ((int) (tmp-val) <= 2) l_time->year= year_2000_handling(l_time->year); val= tmp; break; case 'y': tmp= (char*) val + MY_MIN(2, val_len); l_time->year= (int) my_strtoll10(val, &tmp, &error); val= tmp; l_time->year= year_2000_handling(l_time->year); break; /* Month */ case 'm': case 'c': tmp= (char*) val + MY_MIN(2, val_len); l_time->month= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; case 'M': if ((l_time->month= check_word(my_locale_en_US.month_names, val, val_end, &val)) <= 0) goto err; break; case 'b': if ((l_time->month= check_word(my_locale_en_US.ab_month_names, val, val_end, &val)) <= 0) goto err; break; /* Day */ case 'd': case 'e': tmp= (char*) val + MY_MIN(2, val_len); l_time->day= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; case 'D': tmp= (char*) val + MY_MIN(2, val_len); l_time->day= (int) my_strtoll10(val, &tmp, &error); /* Skip 'st, 'nd, 'th .. */ val= tmp + MY_MIN((int) (val_end-tmp), 2); break; /* Hour */ case 'h': case 'I': case 'l': usa_time= 1; /* fall through */ case 'k': case 'H': tmp= (char*) val + MY_MIN(2, val_len); l_time->hour= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; /* Minute */ case 'i': tmp= (char*) val + MY_MIN(2, val_len); l_time->minute= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; /* Second */ case 's': case 'S': tmp= (char*) val + MY_MIN(2, val_len); l_time->second= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; /* Second part */ case 'f': tmp= (char*) val_end; if (tmp - val > 6) tmp= (char*) val + 6; l_time->second_part= (int) my_strtoll10(val, &tmp, &error); frac_part= 6 - (int) (tmp - val); if (frac_part > 0) l_time->second_part*= (ulong) log_10_int[frac_part]; val= tmp; break; /* AM / PM */ case 'p': if (val_len < 2 || ! usa_time) goto err; if (!my_charset_latin1.strnncoll(val, 2, "PM", 2)) daypart= 12; else if (my_charset_latin1.strnncoll(val, 2, "AM", 2)) goto err; val+= 2; break; /* Exotic things */ case 'W': if ((weekday= check_word(my_locale_en_US.day_names, val, val_end, &val)) <= 0) goto err; break; case 'a': if ((weekday= check_word(my_locale_en_US.ab_day_names, val, val_end, &val)) <= 0) goto err; break; case 'w': tmp= (char*) val + 1; if (unlikely((weekday= (int) my_strtoll10(val, &tmp, &error)) < 0 || weekday >= 7)) goto err; /* We should use the same 1 - 7 scale for %w as for %W */ if (!weekday) weekday= 7; val= tmp; break; case 'j': tmp= (char*) val + MY_MIN(val_len, 3); yearday= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; /* Week numbers */ case 'V': case 'U': case 'v': case 'u': sunday_first_n_first_week_non_iso= (*ptr=='U' || *ptr== 'V'); strict_week_number= (*ptr=='V' || *ptr=='v'); tmp= (char*) val + MY_MIN(val_len, 2); if (unlikely((week_number= (int) my_strtoll10(val, &tmp, &error)) < 0 || (strict_week_number && !week_number) || week_number > 53)) goto err; val= tmp; break; /* Year used with 'strict' %V and %v week numbers */ case 'X': case 'x': strict_week_number_year_type= (*ptr=='X'); tmp= (char*) val + MY_MIN(4, val_len); strict_week_number_year= (int) my_strtoll10(val, &tmp, &error); val= tmp; break; /* Time in AM/PM notation */ case 'r': /* We can't just set error here, as we don't want to generate two warnings in case of errors */ if (extract_date_time(thd, &time_ampm_format, val, (uint)(val_end - val), l_time, cached_timestamp_type, &val, "time", fuzzydate)) DBUG_RETURN(1); break; /* Time in 24-hour notation */ case 'T': if (extract_date_time(thd, &time_24hrs_format, val, (uint)(val_end - val), l_time, cached_timestamp_type, &val, "time", fuzzydate)) DBUG_RETURN(1); break; /* Conversion specifiers that match classes of characters */ case '.': while (my_ispunct(cs, *val) && val != val_end) val++; break; case '@': while (my_isalpha(cs, *val) && val != val_end) val++; break; case '#': while (my_isdigit(cs, *val) && val != val_end) val++; break; default: goto err; } if (unlikely(error)) // Error from my_strtoll10 goto err; } else if (!my_isspace(cs, *ptr)) { if (*val != *ptr) goto err; val++; } } if (usa_time) { if (l_time->hour > 12 || l_time->hour < 1) goto err; l_time->hour= l_time->hour%12+daypart; } /* If we are recursively called for parsing string matching compound specifiers we are already done. */ if (sub_pattern_end) { *sub_pattern_end= val; DBUG_RETURN(0); } if (yearday > 0) { uint days; days= calc_daynr(l_time->year,1,1) + yearday - 1; if (get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day)) goto err; } if (week_number >= 0 && weekday) { int days; uint weekday_b; /* %V,%v require %X,%x resprectively, %U,%u should be used with %Y and not %X or %x */ if ((strict_week_number && (strict_week_number_year < 0 || strict_week_number_year_type != sunday_first_n_first_week_non_iso)) || (!strict_week_number && strict_week_number_year >= 0)) goto err; /* Number of days since year 0 till 1st Jan of this year */ days= calc_daynr((strict_week_number ? strict_week_number_year : l_time->year), 1, 1); /* Which day of week is 1st Jan of this year */ weekday_b= calc_weekday(days, sunday_first_n_first_week_non_iso); /* Below we are going to sum: 1) number of days since year 0 till 1st day of 1st week of this year 2) number of days between 1st week and our week 3) and position of our day in the week */ if (sunday_first_n_first_week_non_iso) { days+= ((weekday_b == 0) ? 0 : 7) - weekday_b + (week_number - 1) * 7 + weekday % 7; } else { days+= ((weekday_b <= 3) ? 0 : 7) - weekday_b + (week_number - 1) * 7 + (weekday - 1); } if (get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day)) goto err; } if (l_time->month > 12 || l_time->day > 31 || l_time->hour > 23 || l_time->minute > 59 || l_time->second > 59) goto err; int was_cut; if (check_date(l_time, fuzzydate | TIME_INVALID_DATES, &was_cut)) goto err; if (val != val_end) { do { if (!my_isspace(&my_charset_latin1,*val)) { ErrConvString err(val_begin, length, &my_charset_bin); make_truncated_value_warning(thd, Sql_condition::WARN_LEVEL_WARN, &err, cached_timestamp_type, nullptr, nullptr, nullptr); break; } } while (++val != val_end); } DBUG_RETURN(0); err: { char buff[128]; strmake(buff, val_begin, MY_MIN(length, sizeof(buff)-1)); push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, ER_WRONG_VALUE_FOR_TYPE, ER_THD(thd, ER_WRONG_VALUE_FOR_TYPE), date_time_type, buff, "str_to_date"); } DBUG_RETURN(1); } /** Create a formatted date/time value in a string. */ static bool make_date_time(const String *format, const MYSQL_TIME *l_time, timestamp_type type, const MY_LOCALE *locale, String *str) { char intbuff[15]; uint hours_i; uint weekday; ulong length; const char *ptr, *end; str->length(0); if (l_time->neg) str->append('-'); end= (ptr= format->ptr()) + format->length(); for (; ptr != end ; ptr++) { if (*ptr != '%' || ptr+1 == end) str->append(*ptr); else { switch (*++ptr) { case 'M': if (type == MYSQL_TIMESTAMP_TIME || !l_time->month) return 1; str->append(locale->month_names->type_names[l_time->month-1], (uint) strlen(locale->month_names->type_names[l_time->month-1]), system_charset_info); break; case 'b': if (type == MYSQL_TIMESTAMP_TIME || !l_time->month) return 1; str->append(locale->ab_month_names->type_names[l_time->month-1], (uint) strlen(locale->ab_month_names->type_names[l_time->month-1]), system_charset_info); break; case 'W': if (type == MYSQL_TIMESTAMP_TIME || !(l_time->month || l_time->year)) return 1; weekday= calc_weekday(calc_daynr(l_time->year,l_time->month, l_time->day),0); str->append(locale->day_names->type_names[weekday], (uint) strlen(locale->day_names->type_names[weekday]), system_charset_info); break; case 'a': if (type == MYSQL_TIMESTAMP_TIME || !(l_time->month || l_time->year)) return 1; weekday=calc_weekday(calc_daynr(l_time->year,l_time->month, l_time->day),0); str->append(locale->ab_day_names->type_names[weekday], (uint) strlen(locale->ab_day_names->type_names[weekday]), system_charset_info); break; case 'D': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->day, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 1, '0'); if (l_time->day >= 10 && l_time->day <= 19) str->append(STRING_WITH_LEN("th")); else { switch (l_time->day %10) { case 1: str->append(STRING_WITH_LEN("st")); break; case 2: str->append(STRING_WITH_LEN("nd")); break; case 3: str->append(STRING_WITH_LEN("rd")); break; default: str->append(STRING_WITH_LEN("th")); break; } } break; case 'Y': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->year, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 4, '0'); break; case 'y': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->year%100, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'm': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->month, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'c': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->month, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 1, '0'); break; case 'd': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->day, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'e': if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(l_time->day, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 1, '0'); break; case 'f': length= (uint) (int10_to_str(l_time->second_part, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 6, '0'); break; case 'H': length= (uint) (int10_to_str(l_time->hour, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'h': case 'I': hours_i= (l_time->hour%24 + 11)%12+1; length= (uint) (int10_to_str(hours_i, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'i': /* minutes */ length= (uint) (int10_to_str(l_time->minute, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'j': if (type == MYSQL_TIMESTAMP_TIME || !l_time->month || !l_time->year) return 1; length= (uint) (int10_to_str(calc_daynr(l_time->year,l_time->month, l_time->day) - calc_daynr(l_time->year,1,1) + 1, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 3, '0'); break; case 'k': length= (uint) (int10_to_str(l_time->hour, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 1, '0'); break; case 'l': hours_i= (l_time->hour%24 + 11)%12+1; length= (uint) (int10_to_str(hours_i, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 1, '0'); break; case 'p': hours_i= l_time->hour%24; str->append(hours_i < 12 ? "AM" : "PM",2); break; case 'r': length= sprintf(intbuff, ((l_time->hour % 24) < 12) ? "%02d:%02d:%02d AM" : "%02d:%02d:%02d PM", (l_time->hour+11)%12+1, l_time->minute, l_time->second); str->append(intbuff, length); break; case 'S': case 's': length= (uint) (int10_to_str(l_time->second, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); break; case 'T': length= sprintf(intbuff, "%02d:%02d:%02d", l_time->hour, l_time->minute, l_time->second); str->append(intbuff, length); break; case 'U': case 'u': { uint year; if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(calc_week(l_time, (*ptr) == 'U' ? WEEK_FIRST_WEEKDAY : WEEK_MONDAY_FIRST, &year), intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); } break; case 'v': case 'V': { uint year; if (type == MYSQL_TIMESTAMP_TIME) return 1; length= (uint) (int10_to_str(calc_week(l_time, ((*ptr) == 'V' ? (WEEK_YEAR | WEEK_FIRST_WEEKDAY) : (WEEK_YEAR | WEEK_MONDAY_FIRST)), &year), intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 2, '0'); } break; case 'x': case 'X': { uint year; if (type == MYSQL_TIMESTAMP_TIME) return 1; (void) calc_week(l_time, ((*ptr) == 'X' ? WEEK_YEAR | WEEK_FIRST_WEEKDAY : WEEK_YEAR | WEEK_MONDAY_FIRST), &year); length= (uint) (int10_to_str(year, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 4, '0'); } break; case 'w': if (type == MYSQL_TIMESTAMP_TIME || !(l_time->month || l_time->year)) return 1; weekday=calc_weekday(calc_daynr(l_time->year,l_time->month, l_time->day),1); length= (uint) (int10_to_str(weekday, intbuff, 10) - intbuff); str->append_with_prefill(intbuff, length, 1, '0'); break; default: str->append(*ptr); break; } } } return 0; } /** @details Get a array of positive numbers from a string object. Each number is separated by 1 non digit character Return error if there is too many numbers. If there is too few numbers, assume that the numbers are left out from the high end. This allows one to give: DAY_TO_SECOND as "D MM:HH:SS", "MM:HH:SS" "HH:SS" or as seconds. @param length: length of str @param cs: charset of str @param values: array of results @param count: count of elements in result array @param transform_msec: if value is true we suppose that the last part of string value is microseconds and we should transform value to six digit value. For example, '1.1' -> '1.100000' */ #define MAX_DIGITS_IN_TIME_SPEC 20 static bool get_interval_info(const char *str, size_t length,CHARSET_INFO *cs, size_t count, ulonglong *values, bool transform_msec) { const char *end=str+length; uint i; size_t field_length= 0; while (str != end && !my_isdigit(cs,*str)) str++; for (i=0 ; i < count ; i++) { ulonglong value; const char *start= str; const char *local_end= end; /* We limit things to 19 digits to not get an overflow. This is ok as this function is meant to read up to microseconds */ if ((local_end-str) > MAX_DIGITS_IN_TIME_SPEC) local_end= str+ MAX_DIGITS_IN_TIME_SPEC; for (value= 0; str != local_end && my_isdigit(cs, *str) ; str++) value= value*10 + *str - '0'; if ((field_length= (size_t)(str - start)) >= MAX_DIGITS_IN_TIME_SPEC) return true; values[i]= value; while (str != end && !my_isdigit(cs,*str)) str++; if (str == end && i != count-1) { i++; /* Change values[0...i-1] -> values[0...count-1] */ bmove_upp((uchar*) (values+count), (uchar*) (values+i), sizeof(*values)*i); bzero((uchar*) values, sizeof(*values)*(count-i)); break; } } if (transform_msec && field_length > 0) { if (field_length < 6) values[count - 1] *= log_10_int[6 - field_length]; else if (field_length > 6) values[count - 1] /= log_10_int[field_length - 6]; } return (str != end); } longlong Item_func_period_add::val_int() { DBUG_ASSERT(fixed == 1); ulong period=(ulong) args[0]->val_int(); int months=(int) args[1]->val_int(); if ((null_value=args[0]->null_value || args[1]->null_value) || period == 0L) return 0; /* purecov: inspected */ return (longlong) convert_month_to_period((uint) ((int) convert_period_to_month(period)+ months)); } longlong Item_func_period_diff::val_int() { DBUG_ASSERT(fixed == 1); ulong period1=(ulong) args[0]->val_int(); ulong period2=(ulong) args[1]->val_int(); if ((null_value=args[0]->null_value || args[1]->null_value)) return 0; /* purecov: inspected */ return (longlong) ((long) convert_period_to_month(period1)- (long) convert_period_to_month(period2)); } longlong Item_func_to_days::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.daynr(); } longlong Item_func_to_seconds::val_int_endpoint(bool left_endp, bool *incl_endp) { DBUG_ASSERT(fixed == 1); // val_int_endpoint() is called only if args[0] is a temporal Item_field Datetime_from_temporal dt(current_thd, args[0], TIME_FUZZY_DATES); if ((null_value= !dt.is_valid_datetime())) { /* got NULL, leave the incl_endp intact */ return LONGLONG_MIN; } /* Set to NULL if invalid date, but keep the value */ null_value= dt.check_date(TIME_NO_ZEROS); /* Even if the evaluation return NULL, seconds is useful for pruning */ return dt.to_seconds(); } longlong Item_func_to_seconds::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; /* Unlike val_int_endpoint(), we cannot use Datetime_from_temporal here. The argument can be of a non-temporal data type. */ Datetime dt(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); return (null_value= !dt.is_valid_datetime()) ? 0 : dt.to_seconds(); } /* Get information about this Item tree monotonicity SYNOPSIS Item_func_to_days::get_monotonicity_info() DESCRIPTION Get information about monotonicity of the function represented by this item tree. RETURN See enum_monotonicity_info. */ enum_monotonicity_info Item_func_to_days::get_monotonicity_info() const { if (args[0]->type() == Item::FIELD_ITEM) { if (args[0]->field_type() == MYSQL_TYPE_DATE) return MONOTONIC_STRICT_INCREASING_NOT_NULL; if (args[0]->field_type() == MYSQL_TYPE_DATETIME) return MONOTONIC_INCREASING_NOT_NULL; } return NON_MONOTONIC; } enum_monotonicity_info Item_func_to_seconds::get_monotonicity_info() const { if (args[0]->type() == Item::FIELD_ITEM) { if (args[0]->field_type() == MYSQL_TYPE_DATE || args[0]->field_type() == MYSQL_TYPE_DATETIME) return MONOTONIC_STRICT_INCREASING_NOT_NULL; } return NON_MONOTONIC; } longlong Item_func_to_days::val_int_endpoint(bool left_endp, bool *incl_endp) { DBUG_ASSERT(fixed == 1); // val_int_endpoint() is only called if args[0] is a temporal Item_field Datetime_from_temporal dt(current_thd, args[0], TIME_CONV_NONE); longlong res; if ((null_value= !dt.is_valid_datetime())) { /* got NULL, leave the incl_endp intact */ return LONGLONG_MIN; } res= (longlong) dt.daynr(); /* Set to NULL if invalid date, but keep the value */ null_value= dt.check_date(TIME_NO_ZEROS); if (null_value) { /* Even if the evaluation return NULL, the calc_daynr is useful for pruning */ if (args[0]->field_type() != MYSQL_TYPE_DATE) *incl_endp= TRUE; return res; } if (args[0]->field_type() == MYSQL_TYPE_DATE) { // TO_DAYS() is strictly monotonic for dates, leave incl_endp intact return res; } /* Handle the special but practically useful case of datetime values that point to day bound ("strictly less" comparison stays intact): col < '2007-09-15 00:00:00' -> TO_DAYS(col) < TO_DAYS('2007-09-15') col > '2007-09-15 23:59:59' -> TO_DAYS(col) > TO_DAYS('2007-09-15') which is different from the general case ("strictly less" changes to "less or equal"): col < '2007-09-15 12:34:56' -> TO_DAYS(col) <= TO_DAYS('2007-09-15') */ const MYSQL_TIME <ime= dt.get_mysql_time()[0]; if ((!left_endp && dt.hhmmssff_is_zero()) || (left_endp && ltime.hour == 23 && ltime.minute == 59 && ltime.second == 59)) /* do nothing */ ; else *incl_endp= TRUE; return res; } longlong Item_func_dayofyear::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.dayofyear(); } longlong Item_func_dayofmonth::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_CONV_NONE, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.get_mysql_time()->day; } longlong Item_func_month::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_CONV_NONE, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.get_mysql_time()->month; } bool Item_func_monthname::fix_length_and_dec() { THD* thd= current_thd; CHARSET_INFO *cs= thd->variables.collation_connection; locale= thd->variables.lc_time_names; collation.set(cs, DERIVATION_COERCIBLE, locale->repertoire()); decimals=0; max_length= locale->max_month_name_length * collation.collation->mbmaxlen; maybe_null=1; return FALSE; } String* Item_func_monthname::val_str(String* str) { DBUG_ASSERT(fixed == 1); const char *month_name; uint err; THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_CONV_NONE, thd)); if ((null_value= (!d.is_valid_datetime() || !d.get_mysql_time()->month))) return (String *) 0; month_name= locale->month_names->type_names[d.get_mysql_time()->month - 1]; str->copy(month_name, (uint) strlen(month_name), &my_charset_utf8mb3_bin, collation.collation, &err); return str; } /** Returns the quarter of the year. */ longlong Item_func_quarter::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_CONV_NONE, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.quarter(); } longlong Item_func_hour::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Time tm(thd, args[0], Time::Options_for_cast(thd)); return (null_value= !tm.is_valid_time()) ? 0 : tm.get_mysql_time()->hour; } longlong Item_func_minute::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Time tm(thd, args[0], Time::Options_for_cast(thd)); return (null_value= !tm.is_valid_time()) ? 0 : tm.get_mysql_time()->minute; } /** Returns the second in time_exp in the range of 0 - 59. */ longlong Item_func_second::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Time tm(thd, args[0], Time::Options_for_cast(thd)); return (null_value= !tm.is_valid_time()) ? 0 : tm.get_mysql_time()->second; } uint week_mode(uint mode) { uint week_format= (mode & 7); if (!(week_format & WEEK_MONDAY_FIRST)) week_format^= WEEK_FIRST_WEEKDAY; return week_format; } /** @verbatim The bits in week_format(for calc_week() function) has the following meaning: WEEK_MONDAY_FIRST (0) If not set Sunday is first day of week If set Monday is first day of week WEEK_YEAR (1) If not set Week is in range 0-53 Week 0 is returned for the the last week of the previous year (for a date at start of january) In this case one can get 53 for the first week of next year. This flag ensures that the week is relevant for the given year. Note that this flag is only relevant if WEEK_JANUARY is not set. If set Week is in range 1-53. In this case one may get week 53 for a date in January (when the week is that last week of previous year) and week 1 for a date in December. WEEK_FIRST_WEEKDAY (2) If not set Weeks are numbered according to ISO 8601:1988 If set The week that contains the first 'first-day-of-week' is week 1. ISO 8601:1988 means that if the week containing January 1 has four or more days in the new year, then it is week 1; Otherwise it is the last week of the previous year, and the next week is week 1. @endverbatim */ longlong Item_func_week::val_int() { DBUG_ASSERT(fixed == 1); uint week_format; THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); if ((null_value= !d.is_valid_datetime())) return 0; if (arg_count > 1) week_format= (uint)args[1]->val_int(); else week_format= thd->variables.default_week_format; return d.week(week_mode(week_format)); } longlong Item_func_yearweek::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.yearweek((week_mode((uint) args[1]->val_int()) | WEEK_YEAR)); } longlong Item_func_weekday::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime dt(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); if ((null_value= !dt.is_valid_datetime())) return 0; return dt.weekday(odbc_type) + MY_TEST(odbc_type); } bool Item_func_dayname::fix_length_and_dec() { THD* thd= current_thd; CHARSET_INFO *cs= thd->variables.collation_connection; locale= thd->variables.lc_time_names; collation.set(cs, DERIVATION_COERCIBLE, locale->repertoire()); decimals=0; max_length= locale->max_day_name_length * collation.collation->mbmaxlen; maybe_null=1; return FALSE; } String* Item_func_dayname::val_str(String* str) { DBUG_ASSERT(fixed == 1); const char *day_name; uint err; THD *thd= current_thd; Datetime dt(thd, args[0], Datetime::Options(TIME_NO_ZEROS, thd)); if ((null_value= !dt.is_valid_datetime())) return (String*) 0; day_name= locale->day_names->type_names[dt.weekday(false)]; str->copy(day_name, (uint) strlen(day_name), &my_charset_utf8mb3_bin, collation.collation, &err); return str; } longlong Item_func_year::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Datetime d(thd, args[0], Datetime::Options(TIME_CONV_NONE, thd)); return (null_value= !d.is_valid_datetime()) ? 0 : d.get_mysql_time()->year; } /* Get information about this Item tree monotonicity SYNOPSIS Item_func_year::get_monotonicity_info() DESCRIPTION Get information about monotonicity of the function represented by this item tree. RETURN See enum_monotonicity_info. */ enum_monotonicity_info Item_func_year::get_monotonicity_info() const { if (args[0]->type() == Item::FIELD_ITEM && (args[0]->field_type() == MYSQL_TYPE_DATE || args[0]->field_type() == MYSQL_TYPE_DATETIME)) return MONOTONIC_INCREASING; return NON_MONOTONIC; } longlong Item_func_year::val_int_endpoint(bool left_endp, bool *incl_endp) { DBUG_ASSERT(fixed == 1); // val_int_endpoint() is cally only if args[0] is a temporal Item_field Datetime_from_temporal dt(current_thd, args[0], TIME_CONV_NONE); if ((null_value= !dt.is_valid_datetime())) { /* got NULL, leave the incl_endp intact */ return LONGLONG_MIN; } /* Handle the special but practically useful case of datetime values that point to year bound ("strictly less" comparison stays intact) : col < '2007-01-01 00:00:00' -> YEAR(col) < 2007 which is different from the general case ("strictly less" changes to "less or equal"): col < '2007-09-15 23:00:00' -> YEAR(col) <= 2007 */ const MYSQL_TIME <ime= dt.get_mysql_time()[0]; if (!left_endp && ltime.day == 1 && ltime.month == 1 && dt.hhmmssff_is_zero()) ; /* do nothing */ else *incl_endp= TRUE; return ltime.year; } bool Item_func_unix_timestamp::get_timestamp_value(my_time_t *seconds, ulong *second_part) { DBUG_ASSERT(fixed == 1); if (args[0]->type() == FIELD_ITEM) { // Optimize timestamp field Field *field=((Item_field*) args[0])->field; if (field->type() == MYSQL_TYPE_TIMESTAMP) { if ((null_value= field->is_null())) return 1; *seconds= field->get_timestamp(second_part); return 0; } } Timestamp_or_zero_datetime_native_null native(current_thd, args[0], true); if ((null_value= native.is_null() || native.is_zero_datetime())) return true; Timestamp tm(native); *seconds= tm.tv().tv_sec; *second_part= tm.tv().tv_usec; return false; } longlong Item_func_unix_timestamp::int_op() { if (arg_count == 0) return (longlong) current_thd->query_start(); ulong second_part; my_time_t seconds; if (get_timestamp_value(&seconds, &second_part)) return 0; return seconds; } my_decimal *Item_func_unix_timestamp::decimal_op(my_decimal* buf) { ulong second_part; my_time_t seconds; if (get_timestamp_value(&seconds, &second_part)) return 0; return seconds2my_decimal(seconds < 0, seconds < 0 ? -seconds : seconds, second_part, buf); } enum_monotonicity_info Item_func_unix_timestamp::get_monotonicity_info() const { if (args[0]->type() == Item::FIELD_ITEM && (args[0]->field_type() == MYSQL_TYPE_TIMESTAMP)) return MONOTONIC_INCREASING; return NON_MONOTONIC; } longlong Item_func_unix_timestamp::val_int_endpoint(bool left_endp, bool *incl_endp) { DBUG_ASSERT(fixed == 1); DBUG_ASSERT(arg_count == 1 && args[0]->type() == Item::FIELD_ITEM && args[0]->field_type() == MYSQL_TYPE_TIMESTAMP); Field *field= ((Item_field*)args[0])->field; /* Leave the incl_endp intact */ ulong unused; my_time_t ts= field->get_timestamp(&unused); null_value= field->is_null(); return ts; } longlong Item_func_time_to_sec::int_op() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Time tm(thd, args[0], Time::Options_for_cast(thd)); return ((null_value= !tm.is_valid_time())) ? 0 : tm.to_seconds(); } my_decimal *Item_func_time_to_sec::decimal_op(my_decimal* buf) { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Time tm(thd, args[0], Time::Options_for_cast(thd)); if ((null_value= !tm.is_valid_time())) return 0; const MYSQL_TIME *ltime= tm.get_mysql_time(); longlong seconds= tm.to_seconds_abs(); return seconds2my_decimal(ltime->neg, seconds, ltime->second_part, buf); } /** Convert a string to a interval value. To make code easy, allow interval objects without separators. */ bool get_interval_value(THD *thd, Item *args, interval_type int_type, INTERVAL *interval) { ulonglong array[5]; longlong UNINIT_VAR(value); const char *UNINIT_VAR(str); size_t UNINIT_VAR(length); CHARSET_INFO *UNINIT_VAR(cs); char buf[100]; String str_value(buf, sizeof(buf), &my_charset_bin); bzero((char*) interval,sizeof(*interval)); if (int_type == INTERVAL_SECOND && args->decimals) { VDec val(args); if (val.is_null()) return true; Sec6 d(val.ptr()); interval->neg= d.neg(); if (d.sec() >= LONGLONG_MAX) { ErrConvDecimal err(val.ptr()); thd->push_warning_truncated_wrong_value("seconds", err.ptr()); return true; } interval->second= d.sec(); interval->second_part= d.usec(); return false; } else if ((int) int_type <= INTERVAL_MICROSECOND) { value= args->val_int(); if (args->null_value) return 1; if (value < 0) { interval->neg=1; value= -value; } } else { String *res; if (!(res= args->val_str_ascii(&str_value))) return (1); /* record negative intervals in interval->neg */ str=res->ptr(); cs= res->charset(); const char *end=str+res->length(); while (str != end && my_isspace(cs,*str)) str++; if (str != end && *str == '-') { interval->neg=1; str++; } length= (size_t) (end-str); // Set up pointers to new str } switch (int_type) { case INTERVAL_YEAR: interval->year= (ulong) value; break; case INTERVAL_QUARTER: interval->month= (ulong)(value*3); break; case INTERVAL_MONTH: interval->month= (ulong) value; break; case INTERVAL_WEEK: interval->day= (ulong)(value*7); break; case INTERVAL_DAY: interval->day= (ulong) value; break; case INTERVAL_HOUR: interval->hour= (ulong) value; break; case INTERVAL_MICROSECOND: interval->second_part=value; break; case INTERVAL_MINUTE: interval->minute=value; break; case INTERVAL_SECOND: interval->second=value; break; case INTERVAL_YEAR_MONTH: // Allow YEAR-MONTH YYYYYMM if (get_interval_info(str,length,cs,2,array,0)) return (1); interval->year= (ulong) array[0]; interval->month= (ulong) array[1]; break; case INTERVAL_DAY_HOUR: if (get_interval_info(str,length,cs,2,array,0)) return (1); interval->day= (ulong) array[0]; interval->hour= (ulong) array[1]; break; case INTERVAL_DAY_MICROSECOND: if (get_interval_info(str,length,cs,5,array,1)) return (1); interval->day= (ulong) array[0]; interval->hour= (ulong) array[1]; interval->minute= array[2]; interval->second= array[3]; interval->second_part= array[4]; break; case INTERVAL_DAY_MINUTE: if (get_interval_info(str,length,cs,3,array,0)) return (1); interval->day= (ulong) array[0]; interval->hour= (ulong) array[1]; interval->minute= array[2]; break; case INTERVAL_DAY_SECOND: if (get_interval_info(str,length,cs,4,array,0)) return (1); interval->day= (ulong) array[0]; interval->hour= (ulong) array[1]; interval->minute= array[2]; interval->second= array[3]; break; case INTERVAL_HOUR_MICROSECOND: if (get_interval_info(str,length,cs,4,array,1)) return (1); interval->hour= (ulong) array[0]; interval->minute= array[1]; interval->second= array[2]; interval->second_part= array[3]; break; case INTERVAL_HOUR_MINUTE: if (get_interval_info(str,length,cs,2,array,0)) return (1); interval->hour= (ulong) array[0]; interval->minute= array[1]; break; case INTERVAL_HOUR_SECOND: if (get_interval_info(str,length,cs,3,array,0)) return (1); interval->hour= (ulong) array[0]; interval->minute= array[1]; interval->second= array[2]; break; case INTERVAL_MINUTE_MICROSECOND: if (get_interval_info(str,length,cs,3,array,1)) return (1); interval->minute= array[0]; interval->second= array[1]; interval->second_part= array[2]; break; case INTERVAL_MINUTE_SECOND: if (get_interval_info(str,length,cs,2,array,0)) return (1); interval->minute= array[0]; interval->second= array[1]; break; case INTERVAL_SECOND_MICROSECOND: if (get_interval_info(str,length,cs,2,array,1)) return (1); interval->second= array[0]; interval->second_part= array[1]; break; case INTERVAL_LAST: /* purecov: begin deadcode */ DBUG_ASSERT(0); break; /* purecov: end */ } return 0; } bool Item_func_from_days::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { longlong value=args[0]->val_int(); if ((null_value= (args[0]->null_value || ((fuzzydate & TIME_NO_ZERO_DATE) && value == 0)))) return true; bzero(ltime, sizeof(MYSQL_TIME)); if (get_date_from_daynr((long) value, <ime->year, <ime->month, <ime->day)) return 0; ltime->time_type= MYSQL_TIMESTAMP_DATE; return 0; } /** Converts current time in my_time_t to MYSQL_TIME representation for local time zone. Defines time zone (local) used for whole CURDATE function. */ void Item_func_curdate_local::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { thd->variables.time_zone->gmt_sec_to_TIME(now_time, thd->query_start()); thd->time_zone_used= 1; } /** Converts current time in my_time_t to MYSQL_TIME representation for UTC time zone. Defines time zone (UTC) used for whole UTC_DATE function. */ void Item_func_curdate_utc::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { my_tz_UTC->gmt_sec_to_TIME(now_time, thd->query_start()); /* We are not flagging this query as using time zone, since it uses fixed UTC-SYSTEM time-zone. */ } bool Item_func_curdate::get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate __attribute__((unused))) { query_id_t query_id= thd->query_id; /* Cache value for this query */ if (last_query_id != query_id) { last_query_id= query_id; store_now_in_TIME(thd, <ime); /* We don't need to set second_part and neg because they already 0 */ ltime.hour= ltime.minute= ltime.second= 0; ltime.time_type= MYSQL_TIMESTAMP_DATE; } *res=ltime; return 0; } bool Item_func_curtime::fix_fields(THD *thd, Item **items) { if (decimals > TIME_SECOND_PART_DIGITS) { my_error(ER_TOO_BIG_PRECISION, MYF(0), static_cast(decimals), func_name(), TIME_SECOND_PART_DIGITS); return 1; } return Item_timefunc::fix_fields(thd, items); } bool Item_func_curtime::get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate __attribute__((unused))) { query_id_t query_id= thd->query_id; /* Cache value for this query */ if (last_query_id != query_id) { last_query_id= query_id; store_now_in_TIME(thd, <ime); } *res= ltime; return 0; } void Item_func_curtime::print(String *str, enum_query_type query_type) { str->append(func_name()); str->append('('); if (decimals) str->append_ulonglong(decimals); str->append(')'); } static void set_sec_part(ulong sec_part, MYSQL_TIME *ltime, Item *item) { DBUG_ASSERT(item->decimals == AUTO_SEC_PART_DIGITS || item->decimals <= TIME_SECOND_PART_DIGITS); if (item->decimals) { ltime->second_part= sec_part; if (item->decimals < TIME_SECOND_PART_DIGITS) my_datetime_trunc(ltime, item->decimals); } } /** Converts current time in my_time_t to MYSQL_TIME representation for local time zone. Defines time zone (local) used for whole CURTIME function. */ void Item_func_curtime_local::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { thd->variables.time_zone->gmt_sec_to_TIME(now_time, thd->query_start()); now_time->year= now_time->month= now_time->day= 0; now_time->time_type= MYSQL_TIMESTAMP_TIME; set_sec_part(thd->query_start_sec_part(), now_time, this); thd->time_zone_used= 1; } /** Converts current time in my_time_t to MYSQL_TIME representation for UTC time zone. Defines time zone (UTC) used for whole UTC_TIME function. */ void Item_func_curtime_utc::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { my_tz_UTC->gmt_sec_to_TIME(now_time, thd->query_start()); now_time->year= now_time->month= now_time->day= 0; now_time->time_type= MYSQL_TIMESTAMP_TIME; set_sec_part(thd->query_start_sec_part(), now_time, this); /* We are not flagging this query as using time zone, since it uses fixed UTC-SYSTEM time-zone. */ } bool Item_func_now::fix_fields(THD *thd, Item **items) { if (decimals > TIME_SECOND_PART_DIGITS) { my_error(ER_TOO_BIG_PRECISION, MYF(0), static_cast(decimals), func_name(), TIME_SECOND_PART_DIGITS); return 1; } return Item_datetimefunc::fix_fields(thd, items); } void Item_func_now::print(String *str, enum_query_type query_type) { str->append(func_name()); str->append('('); if (decimals) str->append_ulonglong(decimals); str->append(')'); } int Item_func_now_local::save_in_field(Field *field, bool no_conversions) { if (field->type() == MYSQL_TYPE_TIMESTAMP) { THD *thd= field->get_thd(); my_time_t ts= thd->query_start(); ulong sec_part= decimals ? thd->query_start_sec_part() : 0; sec_part-= my_time_fraction_remainder(sec_part, decimals); field->set_notnull(); field->store_timestamp(ts, sec_part); return 0; } else return Item_datetimefunc::save_in_field(field, no_conversions); } /** Converts current time in my_time_t to MYSQL_TIME representation for local time zone. Defines time zone (local) used for whole NOW function. */ void Item_func_now_local::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { thd->variables.time_zone->gmt_sec_to_TIME(now_time, thd->query_start()); set_sec_part(thd->query_start_sec_part(), now_time, this); thd->time_zone_used= 1; } /** Converts current time in my_time_t to MYSQL_TIME representation for UTC time zone. Defines time zone (UTC) used for whole UTC_TIMESTAMP function. */ void Item_func_now_utc::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { my_tz_UTC->gmt_sec_to_TIME(now_time, thd->query_start()); set_sec_part(thd->query_start_sec_part(), now_time, this); /* We are not flagging this query as using time zone, since it uses fixed UTC-SYSTEM time-zone. */ } bool Item_func_now::get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate __attribute__((unused))) { query_id_t query_id= thd->query_id; /* Cache value for this query */ if (last_query_id != query_id) { last_query_id= query_id; store_now_in_TIME(thd, <ime); } *res= ltime; return 0; } /** Converts current time in my_time_t to MYSQL_TIME representation for local time zone. Defines time zone (local) used for whole SYSDATE function. */ void Item_func_sysdate_local::store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) { my_hrtime_t now= my_hrtime(); thd->variables.time_zone->gmt_sec_to_TIME(now_time, hrtime_to_my_time(now)); set_sec_part(hrtime_sec_part(now), now_time, this); thd->time_zone_used= 1; } bool Item_func_sysdate_local::get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate __attribute__((unused))) { store_now_in_TIME(thd, res); return 0; } bool Item_func_sec_to_time::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { DBUG_ASSERT(fixed == 1); VSec9 sec(thd, args[0], "seconds", LONGLONG_MAX); if ((null_value= sec.is_null())) return true; sec.round(decimals, thd->temporal_round_mode()); if (sec.sec_to_time(ltime, decimals) && !sec.truncated()) sec.make_truncated_warning(thd, "seconds"); return false; } bool Item_func_date_format::fix_length_and_dec() { THD* thd= current_thd; if (!is_time_format) { if (arg_count < 3) locale= thd->variables.lc_time_names; else if (args[2]->basic_const_item()) locale= args[2]->locale_from_val_str(); } /* Must use this_item() in case it's a local SP variable (for ->max_length and ->str_value) */ Item *arg1= args[1]->this_item(); decimals=0; CHARSET_INFO *cs= thd->variables.collation_connection; my_repertoire_t repertoire= arg1->collation.repertoire; if (!thd->variables.lc_time_names->is_ascii) repertoire|= MY_REPERTOIRE_EXTENDED; collation.set(cs, arg1->collation.derivation, repertoire); StringBuffer buffer; String *str; if (args[1]->basic_const_item() && (str= args[1]->val_str(&buffer))) { // Optimize the normal case fixed_length=1; max_length= format_length(str) * collation.collation->mbmaxlen; } else { fixed_length=0; max_length=MY_MIN(arg1->max_length, MAX_BLOB_WIDTH) * 10 * collation.collation->mbmaxlen; set_if_smaller(max_length,MAX_BLOB_WIDTH); } maybe_null=1; // If wrong date return FALSE; } bool Item_func_date_format::eq(const Item *item, bool binary_cmp) const { Item_func_date_format *item_func; if (item->type() != FUNC_ITEM) return 0; if (func_name() != ((Item_func*) item)->func_name()) return 0; if (this == item) return 1; item_func= (Item_func_date_format*) item; if (arg_count != item_func->arg_count) return 0; if (!args[0]->eq(item_func->args[0], binary_cmp)) return 0; /* We must compare format string case sensitive. This needed because format modifiers with different case, for example %m and %M, have different meaning. */ if (!args[1]->eq(item_func->args[1], 1)) return 0; if (arg_count > 2 && !args[2]->eq(item_func->args[2], 1)) return 0; return 1; } uint Item_func_date_format::format_length(const String *format) { uint size=0; const char *ptr=format->ptr(); const char *end=ptr+format->length(); for (; ptr != end ; ptr++) { if (*ptr != '%' || ptr == end-1) size++; else { switch(*++ptr) { case 'M': /* month, textual */ case 'W': /* day (of the week), textual */ size += 64; /* large for UTF8 locale data */ break; case 'D': /* day (of the month), numeric plus english suffix */ case 'Y': /* year, numeric, 4 digits */ case 'x': /* Year, used with 'v' */ case 'X': /* Year, used with 'v, where week starts with Monday' */ size += 4; break; case 'a': /* locale's abbreviated weekday name (Sun..Sat) */ case 'b': /* locale's abbreviated month name (Jan.Dec) */ size += 32; /* large for UTF8 locale data */ break; case 'j': /* day of year (001..366) */ size += 3; break; case 'U': /* week (00..52) */ case 'u': /* week (00..52), where week starts with Monday */ case 'V': /* week 1..53 used with 'x' */ case 'v': /* week 1..53 used with 'x', where week starts with Monday */ case 'y': /* year, numeric, 2 digits */ case 'm': /* month, numeric */ case 'd': /* day (of the month), numeric */ case 'h': /* hour (01..12) */ case 'I': /* --||-- */ case 'i': /* minutes, numeric */ case 'l': /* hour ( 1..12) */ case 'p': /* locale's AM or PM */ case 'S': /* second (00..61) */ case 's': /* seconds, numeric */ case 'c': /* month (0..12) */ case 'e': /* day (0..31) */ size += 2; break; case 'k': /* hour ( 0..23) */ case 'H': /* hour (00..23; value > 23 OK, padding always 2-digit) */ size += 7; /* docs allow > 23, range depends on sizeof(unsigned int) */ break; case 'r': /* time, 12-hour (hh:mm:ss [AP]M) */ size += 11; break; case 'T': /* time, 24-hour (hh:mm:ss) */ size += 8; break; case 'f': /* microseconds */ size += 6; break; case 'w': /* day (of the week), numeric */ case '%': default: size++; break; } } } return size; } String *Item_func_date_format::val_str(String *str) { StringBuffer<64> format_buffer; String *format; MYSQL_TIME l_time; uint size; const MY_LOCALE *lc= 0; DBUG_ASSERT(fixed == 1); date_conv_mode_t mode= is_time_format ? TIME_TIME_ONLY : TIME_CONV_NONE; THD *thd= current_thd; if ((null_value= args[0]->get_date(thd, &l_time, Temporal::Options(mode, thd)))) return 0; if (!(format= args[1]->val_str(&format_buffer)) || !format->length()) goto null_date; if (!is_time_format && !(lc= locale) && !(lc= args[2]->locale_from_val_str())) goto null_date; // invalid locale if (fixed_length) size=max_length; else size=format_length(format); if (size < MAX_DATE_STRING_REP_LENGTH) size= MAX_DATE_STRING_REP_LENGTH; DBUG_ASSERT(format != str); if (str->alloc(size)) goto null_date; /* Create the result string */ str->set_charset(collation.collation); if (!make_date_time(format, &l_time, is_time_format ? MYSQL_TIMESTAMP_TIME : MYSQL_TIMESTAMP_DATE, lc, str)) return str; null_date: null_value=1; return 0; } bool Item_func_from_unixtime::fix_length_and_dec() { THD *thd= current_thd; thd->time_zone_used= 1; tz= thd->variables.time_zone; Type_std_attributes::set( Type_temporal_attributes_not_fixed_dec(MAX_DATETIME_WIDTH, args[0]->decimals, false), DTCollation_numeric()); maybe_null= true; return FALSE; } bool Item_func_from_unixtime::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate __attribute__((unused))) { bzero((char *)ltime, sizeof(*ltime)); ltime->time_type= MYSQL_TIMESTAMP_TIME; VSec9 sec(thd, args[0], "unixtime", TIMESTAMP_MAX_VALUE); DBUG_ASSERT(sec.is_null() || sec.sec() <= TIMESTAMP_MAX_VALUE); if (sec.is_null() || sec.truncated() || sec.neg()) return (null_value= 1); sec.round(MY_MIN(decimals, TIME_SECOND_PART_DIGITS), thd->temporal_round_mode()); if (sec.sec() > TIMESTAMP_MAX_VALUE) return (null_value= true); // Went out of range after rounding tz->gmt_sec_to_TIME(ltime, (my_time_t) sec.sec()); ltime->second_part= sec.usec(); return (null_value= 0); } bool Item_func_convert_tz::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate __attribute__((unused))) { my_time_t my_time_tmp; String str; if (!from_tz_cached) { from_tz= my_tz_find(thd, args[1]->val_str_ascii(&str)); from_tz_cached= args[1]->const_item(); } if (!to_tz_cached) { to_tz= my_tz_find(thd, args[2]->val_str_ascii(&str)); to_tz_cached= args[2]->const_item(); } if ((null_value= (from_tz == 0 || to_tz == 0))) return true; Datetime::Options opt(TIME_NO_ZEROS, thd); Datetime *dt= new(ltime) Datetime(thd, args[0], opt); if ((null_value= !dt->is_valid_datetime())) return true; { uint not_used; my_time_tmp= from_tz->TIME_to_gmt_sec(ltime, ¬_used); ulong sec_part= ltime->second_part; /* my_time_tmp is guaranteed to be in the allowed range */ if (my_time_tmp) to_tz->gmt_sec_to_TIME(ltime, my_time_tmp); /* we rely on the fact that no timezone conversion can change sec_part */ ltime->second_part= sec_part; } return (null_value= 0); } void Item_func_convert_tz::cleanup() { from_tz_cached= to_tz_cached= 0; Item_datetimefunc::cleanup(); } bool Item_date_add_interval::fix_length_and_dec() { enum_field_types arg0_field_type; if (!args[0]->type_handler()->is_traditional_scalar_type()) { my_error(ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION, MYF(0), args[0]->type_handler()->name().ptr(), "interval", func_name()); return TRUE; } /* The field type for the result of an Item_datefunc is defined as follows: - If first arg is a MYSQL_TYPE_DATETIME result is MYSQL_TYPE_DATETIME - If first arg is a MYSQL_TYPE_DATE and the interval type uses hours, minutes or seconds then type is MYSQL_TYPE_DATETIME otherwise it's MYSQL_TYPE_DATE - if first arg is a MYSQL_TYPE_TIME and the interval type isn't using anything larger than days, then the result is MYSQL_TYPE_TIME, otherwise - MYSQL_TYPE_DATETIME. - Otherwise the result is MYSQL_TYPE_STRING (This is because you can't know if the string contains a DATE, MYSQL_TIME or DATETIME argument) */ arg0_field_type= args[0]->field_type(); if (arg0_field_type == MYSQL_TYPE_DATETIME || arg0_field_type == MYSQL_TYPE_TIMESTAMP) { set_func_handler(&func_handler_date_add_interval_datetime); } else if (arg0_field_type == MYSQL_TYPE_DATE) { if (int_type <= INTERVAL_DAY || int_type == INTERVAL_YEAR_MONTH) set_func_handler(&func_handler_date_add_interval_date); else set_func_handler(&func_handler_date_add_interval_datetime); } else if (arg0_field_type == MYSQL_TYPE_TIME) { if (int_type >= INTERVAL_DAY && int_type != INTERVAL_YEAR_MONTH) set_func_handler(&func_handler_date_add_interval_time); else set_func_handler(&func_handler_date_add_interval_datetime_arg0_time); } else { set_func_handler(&func_handler_date_add_interval_string); } maybe_null= true; return m_func_handler->fix_length_and_dec(this); } bool Func_handler_date_add_interval_datetime_arg0_time:: get_date(THD *thd, Item_handled_func *item, MYSQL_TIME *to, date_mode_t fuzzy) const { // time_expr + INTERVAL {YEAR|QUARTER|MONTH|WEEK|YEAR_MONTH} push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, ER_DATETIME_FUNCTION_OVERFLOW, ER_THD(thd, ER_DATETIME_FUNCTION_OVERFLOW), "time"); return (item->null_value= true); } bool Item_date_add_interval::eq(const Item *item, bool binary_cmp) const { if (!Item_func::eq(item, binary_cmp)) return 0; Item_date_add_interval *other= (Item_date_add_interval*) item; return ((int_type == other->int_type) && (date_sub_interval == other->date_sub_interval)); } /* 'interval_names' reflects the order of the enumeration interval_type. See item_timefunc.h */ static const char *interval_names[]= { "year", "quarter", "month", "week", "day", "hour", "minute", "second", "microsecond", "year_month", "day_hour", "day_minute", "day_second", "hour_minute", "hour_second", "minute_second", "day_microsecond", "hour_microsecond", "minute_microsecond", "second_microsecond" }; void Item_date_add_interval::print(String *str, enum_query_type query_type) { args[0]->print_parenthesised(str, query_type, INTERVAL_PRECEDENCE); str->append(date_sub_interval?" - interval ":" + interval "); args[1]->print(str, query_type); str->append(' '); str->append(interval_names[int_type]); } void Item_extract::print(String *str, enum_query_type query_type) { str->append(STRING_WITH_LEN("extract(")); str->append(interval_names[int_type]); str->append(STRING_WITH_LEN(" from ")); args[0]->print(str, query_type); str->append(')'); } bool Item_extract::check_arguments() const { if (!args[0]->type_handler()->can_return_extract_source(int_type)) { char tmp[64]; my_snprintf(tmp, sizeof(tmp), "extract(%s)", interval_names[int_type]); my_error(ER_ILLEGAL_PARAMETER_DATA_TYPE_FOR_OPERATION, MYF(0), args[0]->type_handler()->name().ptr(), tmp); return true; } return false; } bool Item_extract::fix_length_and_dec() { maybe_null=1; // If wrong date uint32 daylen= args[0]->cmp_type() == TIME_RESULT ? 2 : TIME_MAX_INTERVAL_DAY_CHAR_LENGTH; switch (int_type) { case INTERVAL_YEAR: set_date_length(4); break; // YYYY case INTERVAL_YEAR_MONTH: set_date_length(6); break; // YYYYMM case INTERVAL_QUARTER: set_date_length(2); break; // 1..4 case INTERVAL_MONTH: set_date_length(2); break; // MM case INTERVAL_WEEK: set_date_length(2); break; // 0..52 case INTERVAL_DAY: set_day_length(daylen); break; // DD case INTERVAL_DAY_HOUR: set_day_length(daylen+2); break; // DDhh case INTERVAL_DAY_MINUTE: set_day_length(daylen+4); break; // DDhhmm case INTERVAL_DAY_SECOND: set_day_length(daylen+6); break; // DDhhmmss case INTERVAL_HOUR: set_time_length(2); break; // hh case INTERVAL_HOUR_MINUTE: set_time_length(4); break; // hhmm case INTERVAL_HOUR_SECOND: set_time_length(6); break; // hhmmss case INTERVAL_MINUTE: set_time_length(2); break; // mm case INTERVAL_MINUTE_SECOND: set_time_length(4); break; // mmss case INTERVAL_SECOND: set_time_length(2); break; // ss case INTERVAL_MICROSECOND: set_time_length(6); break; // ffffff case INTERVAL_DAY_MICROSECOND: set_time_length(daylen+12); break; // DDhhmmssffffff case INTERVAL_HOUR_MICROSECOND: set_time_length(12); break; // hhmmssffffff case INTERVAL_MINUTE_MICROSECOND: set_time_length(10); break; // mmssffffff case INTERVAL_SECOND_MICROSECOND: set_time_length(8); break; // ssffffff case INTERVAL_LAST: DBUG_ASSERT(0); break; /* purecov: deadcode */ } return FALSE; } uint Extract_source::week(THD *thd) const { DBUG_ASSERT(is_valid_extract_source()); uint year; ulong week_format= current_thd->variables.default_week_format; return calc_week(this, week_mode(week_format), &year); } longlong Item_extract::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Extract_source dt(thd, args[0], m_date_mode); if ((null_value= !dt.is_valid_extract_source())) return 0; switch (int_type) { case INTERVAL_YEAR: return dt.year(); case INTERVAL_YEAR_MONTH: return dt.year_month(); case INTERVAL_QUARTER: return dt.quarter(); case INTERVAL_MONTH: return dt.month(); case INTERVAL_WEEK: return dt.week(thd); case INTERVAL_DAY: return dt.day(); case INTERVAL_DAY_HOUR: return dt.day_hour(); case INTERVAL_DAY_MINUTE: return dt.day_minute(); case INTERVAL_DAY_SECOND: return dt.day_second(); case INTERVAL_HOUR: return dt.hour(); case INTERVAL_HOUR_MINUTE: return dt.hour_minute(); case INTERVAL_HOUR_SECOND: return dt.hour_second(); case INTERVAL_MINUTE: return dt.minute(); case INTERVAL_MINUTE_SECOND: return dt.minute_second(); case INTERVAL_SECOND: return dt.second(); case INTERVAL_MICROSECOND: return dt.microsecond(); case INTERVAL_DAY_MICROSECOND: return dt.day_microsecond(); case INTERVAL_HOUR_MICROSECOND: return dt.hour_microsecond(); case INTERVAL_MINUTE_MICROSECOND: return dt.minute_microsecond(); case INTERVAL_SECOND_MICROSECOND: return dt.second_microsecond(); case INTERVAL_LAST: DBUG_ASSERT(0); break; /* purecov: deadcode */ } return 0; // Impossible } bool Item_extract::eq(const Item *item, bool binary_cmp) const { if (this == item) return 1; if (item->type() != FUNC_ITEM || functype() != ((Item_func*)item)->functype()) return 0; Item_extract* ie= (Item_extract*)item; if (ie->int_type != int_type) return 0; if (!args[0]->eq(ie->args[0], binary_cmp)) return 0; return 1; } bool Item_char_typecast::eq(const Item *item, bool binary_cmp) const { if (this == item) return 1; if (item->type() != FUNC_ITEM || functype() != ((Item_func*)item)->functype()) return 0; Item_char_typecast *cast= (Item_char_typecast*)item; if (cast_length != cast->cast_length || cast_cs != cast->cast_cs) return 0; if (!args[0]->eq(cast->args[0], binary_cmp)) return 0; return 1; } void Item_func::print_cast_temporal(String *str, enum_query_type query_type) { char buf[32]; str->append(STRING_WITH_LEN("cast(")); args[0]->print(str, query_type); str->append(STRING_WITH_LEN(" as ")); const Name name= type_handler()->name(); str->append(name.ptr(), name.length()); if (decimals && decimals != NOT_FIXED_DEC) { str->append('('); str->append(llstr(decimals, buf)); str->append(')'); } str->append(')'); } void Item_char_typecast::print(String *str, enum_query_type query_type) { str->append(STRING_WITH_LEN("cast(")); args[0]->print(str, query_type); str->append(STRING_WITH_LEN(" as char")); if (cast_length != ~0U) { str->append('('); char buffer[20]; // my_charset_bin is good enough for numbers String st(buffer, sizeof(buffer), &my_charset_bin); st.set(static_cast(cast_length), &my_charset_bin); str->append(st); str->append(')'); } if (cast_cs) { str->append(STRING_WITH_LEN(" charset ")); str->append(cast_cs->csname); } str->append(')'); } void Item_char_typecast::check_truncation_with_warn(String *src, size_t dstlen) { if (dstlen < src->length()) { THD *thd= current_thd; char char_type[40]; ErrConvString err(src); bool save_abort_on_warning= thd->abort_on_warning; thd->abort_on_warning&= !m_suppress_warning_to_error_escalation; my_snprintf(char_type, sizeof(char_type), "%s(%lu)", cast_cs == &my_charset_bin ? "BINARY" : "CHAR", (ulong) cast_length); push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, ER_TRUNCATED_WRONG_VALUE, ER_THD(thd, ER_TRUNCATED_WRONG_VALUE), char_type, err.ptr()); thd->abort_on_warning= save_abort_on_warning; } } String *Item_char_typecast::reuse(String *src, size_t length) { DBUG_ASSERT(length <= src->length()); check_truncation_with_warn(src, length); tmp_value.set(src->ptr(), length, cast_cs); return &tmp_value; } /* Make a copy, to handle conversion or fix bad bytes. */ String *Item_char_typecast::copy(String *str, CHARSET_INFO *strcs) { String_copier_for_item copier(current_thd); if (copier.copy_with_warn(cast_cs, &tmp_value, strcs, str->ptr(), str->length(), cast_length)) { null_value= 1; // EOM return 0; } check_truncation_with_warn(str, (uint)(copier.source_end_pos() - str->ptr())); return &tmp_value; } uint Item_char_typecast::adjusted_length_with_warn(uint length) { if (length <= current_thd->variables.max_allowed_packet) return length; THD *thd= current_thd; push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, ER_WARN_ALLOWED_PACKET_OVERFLOWED, ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED), cast_cs == &my_charset_bin ? "cast_as_binary" : func_name(), thd->variables.max_allowed_packet); return thd->variables.max_allowed_packet; } String *Item_char_typecast::val_str_generic(String *str) { DBUG_ASSERT(fixed == 1); String *res; if (has_explicit_length()) cast_length= adjusted_length_with_warn(cast_length); if (!(res= args[0]->val_str(str))) { null_value= 1; return 0; } if (cast_cs == &my_charset_bin && has_explicit_length() && cast_length > res->length()) { // Special case: pad binary value with trailing 0x00 DBUG_ASSERT(cast_length <= current_thd->variables.max_allowed_packet); if (res->alloced_length() < cast_length) { str_value.alloc(cast_length); str_value.copy(*res); res= &str_value; } bzero((char*) res->ptr() + res->length(), cast_length - res->length()); res->length(cast_length); res->set_charset(&my_charset_bin); } else { /* from_cs is 0 in the case where the result set may vary between calls, for example with dynamic columns. */ CHARSET_INFO *cs= from_cs ? from_cs : res->charset(); if (!charset_conversion) { // Try to reuse the original string (if well formed). Well_formed_prefix prefix(cs, res->ptr(), res->end(), cast_length); if (!prefix.well_formed_error_pos()) res= reuse(res, prefix.length()); goto end; } // Character set conversion, or bad bytes were found. if (!(res= copy(res, cs))) return 0; } end: return ((null_value= (res->length() > adjusted_length_with_warn(res->length())))) ? 0 : res; } String *Item_char_typecast::val_str_binary_from_native(String *str) { DBUG_ASSERT(fixed == 1); DBUG_ASSERT(cast_cs == &my_charset_bin); NativeBuffer native; if (args[0]->val_native(current_thd, &native)) { null_value= 1; return 0; } if (has_explicit_length()) { cast_length= adjusted_length_with_warn(cast_length); if (cast_length > native.length()) { // add trailing 0x00s DBUG_ASSERT(cast_length <= current_thd->variables.max_allowed_packet); str->alloc(cast_length); str->copy(native.ptr(), native.length(), &my_charset_bin); bzero((char*) str->end(), cast_length - str->length()); str->length(cast_length); } else str->copy(native.ptr(), cast_length, &my_charset_bin); } else str->copy(native.ptr(), native.length(), &my_charset_bin); return ((null_value= (str->length() > adjusted_length_with_warn(str->length())))) ? 0 : str; } class Item_char_typecast_func_handler: public Item_handled_func::Handler_str { public: const Type_handler *return_type_handler(const Item_handled_func *item) const { return Type_handler::string_type_handler(item->max_length); } const Type_handler * type_handler_for_create_select(const Item_handled_func *item) const { return return_type_handler(item)->type_handler_for_tmp_table(item); } bool fix_length_and_dec(Item_handled_func *item) const { return false; } String *val_str(Item_handled_func *item, String *to) const { DBUG_ASSERT(dynamic_cast(item)); return static_cast(item)->val_str_generic(to); } }; static Item_char_typecast_func_handler item_char_typecast_func_handler; void Item_char_typecast::fix_length_and_dec_numeric() { fix_length_and_dec_internal(from_cs= cast_cs->mbminlen == 1 ? cast_cs : &my_charset_latin1); set_func_handler(&item_char_typecast_func_handler); } void Item_char_typecast::fix_length_and_dec_generic() { fix_length_and_dec_internal(from_cs= args[0]->dynamic_result() ? 0 : args[0]->collation.collation); set_func_handler(&item_char_typecast_func_handler); } void Item_char_typecast::fix_length_and_dec_str() { fix_length_and_dec_generic(); m_suppress_warning_to_error_escalation= true; set_func_handler(&item_char_typecast_func_handler); } void Item_char_typecast::fix_length_and_dec_native_to_binary(uint32 octet_length) { collation.set(&my_charset_bin, DERIVATION_IMPLICIT); max_length= has_explicit_length() ? (uint32) cast_length : octet_length; maybe_null|= current_thd->is_strict_mode(); } void Item_char_typecast::fix_length_and_dec_internal(CHARSET_INFO *from_cs) { uint32 char_length; /* We always force character set conversion if cast_cs is a multi-byte character set. It guarantees that the result of CAST is a well-formed string. For single-byte character sets we allow just to copy from the argument. A single-byte character sets string is always well-formed. There is a special trick to convert form a number to ucs2. As numbers have my_charset_bin as their character set, it wouldn't do conversion to ucs2 without an additional action. To force conversion, we should pretend to be non-binary. Let's choose from_cs this way: - If the argument in a number and cast_cs is ucs2 (i.e. mbminlen > 1), then from_cs is set to latin1, to perform latin1 -> ucs2 conversion. - If the argument is a number and cast_cs is ASCII-compatible (i.e. mbminlen == 1), then from_cs is set to cast_cs, which allows just to take over the args[0]->val_str() result and thus avoid unnecessary character set conversion. - If the argument is not a number, then from_cs is set to the argument's charset. - If argument has a dynamic collation (can change from call to call) we set from_cs to 0 as a marker that we have to take the collation from the result string. Note (TODO): we could use repertoire technique here. */ charset_conversion= !from_cs || (cast_cs->mbmaxlen > 1) || (!my_charset_same(from_cs, cast_cs) && from_cs != &my_charset_bin && cast_cs != &my_charset_bin); collation.set(cast_cs, DERIVATION_IMPLICIT); char_length= ((cast_length != ~0U) ? cast_length : args[0]->max_length / (cast_cs == &my_charset_bin ? 1 : args[0]->collation.collation->mbmaxlen)); max_length= char_length * cast_cs->mbmaxlen; // Add NULL-ability in strict mode. See Item_str_func::fix_fields() maybe_null= maybe_null || current_thd->is_strict_mode(); } bool Item_time_typecast::get_date(THD *thd, MYSQL_TIME *to, date_mode_t mode) { Time *tm= new(to) Time(thd, args[0], Time::Options_for_cast(mode, thd), MY_MIN(decimals, TIME_SECOND_PART_DIGITS)); return (null_value= !tm->is_valid_time()); } Sql_mode_dependency Item_time_typecast::value_depends_on_sql_mode() const { return Item_timefunc::value_depends_on_sql_mode() | Sql_mode_dependency(decimals < args[0]->decimals ? MODE_TIME_ROUND_FRACTIONAL : 0, 0); } bool Item_date_typecast::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { date_mode_t tmp= (fuzzydate | sql_mode_for_dates(thd)) & ~TIME_TIME_ONLY; // Force truncation Date *d= new(ltime) Date(thd, args[0], Date::Options(date_conv_mode_t(tmp))); return (null_value= !d->is_valid_date()); } bool Item_datetime_typecast::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { date_mode_t tmp= (fuzzydate | sql_mode_for_dates(thd)) & ~TIME_TIME_ONLY; // Force rounding if the current sql_mode says so Datetime::Options opt(date_conv_mode_t(tmp), thd); Datetime *dt= new(ltime) Datetime(thd, args[0], opt, MY_MIN(decimals, TIME_SECOND_PART_DIGITS)); return (null_value= !dt->is_valid_datetime()); } Sql_mode_dependency Item_datetime_typecast::value_depends_on_sql_mode() const { return Item_datetimefunc::value_depends_on_sql_mode() | Sql_mode_dependency(decimals < args[0]->decimals ? MODE_TIME_ROUND_FRACTIONAL : 0, 0); } /** MAKEDATE(a,b) is a date function that creates a date value from a year and day value. NOTES: As arguments are integers, we can't know if the year is a 2 digit or 4 digit year. In this case we treat all years < 100 as 2 digit years. Ie, this is not safe for dates between 0000-01-01 and 0099-12-31 */ bool Item_func_makedate::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { DBUG_ASSERT(fixed == 1); long year, days, daynr= (long) args[1]->val_int(); VYear vyear(args[0]); if (vyear.is_null() || args[1]->null_value || vyear.truncated() || daynr <= 0) goto err; if ((year= (long) vyear.year()) < 100) year= year_2000_handling(year); days= calc_daynr(year,1,1) + daynr - 1; if (get_date_from_daynr(days, <ime->year, <ime->month, <ime->day)) goto err; ltime->time_type= MYSQL_TIMESTAMP_DATE; ltime->neg= 0; ltime->hour= ltime->minute= ltime->second= ltime->second_part= 0; return (null_value= 0); err: return (null_value= 1); } bool Item_func_add_time::fix_length_and_dec() { enum_field_types arg0_field_type; if (!args[0]->type_handler()->is_traditional_scalar_type() || !args[1]->type_handler()->is_traditional_scalar_type()) { my_error(ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION, MYF(0), args[0]->type_handler()->name().ptr(), args[1]->type_handler()->name().ptr(), func_name()); return TRUE; } /* The field type for the result of an Item_func_add_time function is defined as follows: - If first arg is a MYSQL_TYPE_DATETIME or MYSQL_TYPE_TIMESTAMP result is MYSQL_TYPE_DATETIME - If first arg is a MYSQL_TYPE_TIME result is MYSQL_TYPE_TIME - Otherwise the result is MYSQL_TYPE_STRING */ arg0_field_type= args[0]->field_type(); if (arg0_field_type == MYSQL_TYPE_DATE || arg0_field_type == MYSQL_TYPE_DATETIME || arg0_field_type == MYSQL_TYPE_TIMESTAMP) { set_func_handler(sign > 0 ? &func_handler_add_time_datetime_add : &func_handler_add_time_datetime_sub); } else if (arg0_field_type == MYSQL_TYPE_TIME) { set_func_handler(sign > 0 ? &func_handler_add_time_time_add : &func_handler_add_time_time_sub); } else { set_func_handler(sign > 0 ? &func_handler_add_time_string_add : &func_handler_add_time_string_sub); } maybe_null= true; return m_func_handler->fix_length_and_dec(this); } /** TIMEDIFF(t,s) is a time function that calculates the time value between a start and end time. t and s: time_or_datetime_expression Result: Time value */ bool Item_func_timediff::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { DBUG_ASSERT(fixed == 1); int l_sign= 1; MYSQL_TIME l_time1,l_time2,l_time3; /* the following may be true in, for example, date_add(timediff(...), ... */ if (fuzzydate & TIME_NO_ZERO_IN_DATE) return (null_value= 1); if (args[0]->get_time(thd, &l_time1) || args[1]->get_time(thd, &l_time2) || l_time1.time_type != l_time2.time_type) return (null_value= 1); if (l_time1.neg != l_time2.neg) l_sign= -l_sign; if (calc_time_diff(&l_time1, &l_time2, l_sign, &l_time3, fuzzydate)) return (null_value= 1); *ltime= l_time3; return (null_value= adjust_time_range_with_warn(thd, ltime, decimals)); } /** MAKETIME(h,m,s) is a time function that calculates a time value from the total number of hours, minutes, and seconds. Result: Time value */ bool Item_func_maketime::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { DBUG_ASSERT(fixed == 1); Longlong_hybrid hour(args[0]->val_int(), args[0]->unsigned_flag); longlong minute= args[1]->val_int(); VSec9 sec(thd, args[2], "seconds", 59); DBUG_ASSERT(sec.is_null() || sec.sec() <= 59); if (args[0]->null_value || args[1]->null_value || sec.is_null() || minute < 0 || minute > 59 || sec.neg() || sec.truncated()) return (null_value= 1); int warn; new(ltime) Time(&warn, hour.neg(), hour.abs(), (uint) minute, sec.to_const_sec9(), thd->temporal_round_mode(), decimals); if (warn) { // use check_time_range() to set ltime to the max value depending on dec int unused; ltime->hour= TIME_MAX_HOUR + 1; check_time_range(ltime, decimals, &unused); char buf[28]; char *ptr= longlong10_to_str(hour.value(), buf, hour.is_unsigned() ? 10 : -10); int len = (int)(ptr - buf) + sprintf(ptr, ":%02u:%02u", (uint) minute, (uint) sec.sec()); ErrConvString err(buf, len, &my_charset_bin); thd->push_warning_truncated_wrong_value("time", err.ptr()); } return (null_value= 0); } /** MICROSECOND(a) is a function ( extraction) that extracts the microseconds from a. a: Datetime or time value Result: int value */ longlong Item_func_microsecond::val_int() { DBUG_ASSERT(fixed == 1); THD *thd= current_thd; Time tm(thd, args[0], Time::Options_for_cast(thd)); return ((null_value= !tm.is_valid_time())) ? 0 : tm.get_mysql_time()->second_part; } longlong Item_func_timestamp_diff::val_int() { MYSQL_TIME ltime1, ltime2; ulonglong seconds; ulong microseconds; long months= 0; int neg= 1; THD *thd= current_thd; Datetime::Options opt(TIME_NO_ZEROS, thd); null_value= 0; if (Datetime(thd, args[0], opt).copy_to_mysql_time(<ime1) || Datetime(thd, args[1], opt).copy_to_mysql_time(<ime2)) goto null_date; if (calc_time_diff(<ime2,<ime1, 1, &seconds, µseconds)) neg= -1; if (int_type == INTERVAL_YEAR || int_type == INTERVAL_QUARTER || int_type == INTERVAL_MONTH) { uint year_beg, year_end, month_beg, month_end, day_beg, day_end; uint years= 0; uint second_beg, second_end, microsecond_beg, microsecond_end; if (neg == -1) { year_beg= ltime2.year; year_end= ltime1.year; month_beg= ltime2.month; month_end= ltime1.month; day_beg= ltime2.day; day_end= ltime1.day; second_beg= ltime2.hour * 3600 + ltime2.minute * 60 + ltime2.second; second_end= ltime1.hour * 3600 + ltime1.minute * 60 + ltime1.second; microsecond_beg= ltime2.second_part; microsecond_end= ltime1.second_part; } else { year_beg= ltime1.year; year_end= ltime2.year; month_beg= ltime1.month; month_end= ltime2.month; day_beg= ltime1.day; day_end= ltime2.day; second_beg= ltime1.hour * 3600 + ltime1.minute * 60 + ltime1.second; second_end= ltime2.hour * 3600 + ltime2.minute * 60 + ltime2.second; microsecond_beg= ltime1.second_part; microsecond_end= ltime2.second_part; } /* calc years */ years= year_end - year_beg; if (month_end < month_beg || (month_end == month_beg && day_end < day_beg)) years-= 1; /* calc months */ months= 12*years; if (month_end < month_beg || (month_end == month_beg && day_end < day_beg)) months+= 12 - (month_beg - month_end); else months+= (month_end - month_beg); if (day_end < day_beg) months-= 1; else if ((day_end == day_beg) && ((second_end < second_beg) || (second_end == second_beg && microsecond_end < microsecond_beg))) months-= 1; } switch (int_type) { case INTERVAL_YEAR: return months/12*neg; case INTERVAL_QUARTER: return months/3*neg; case INTERVAL_MONTH: return months*neg; case INTERVAL_WEEK: return ((longlong) (seconds / SECONDS_IN_24H / 7L)) * neg; case INTERVAL_DAY: return ((longlong) (seconds / SECONDS_IN_24H)) * neg; case INTERVAL_HOUR: return ((longlong) (seconds / 3600L)) * neg; case INTERVAL_MINUTE: return ((longlong) (seconds / 60L)) * neg; case INTERVAL_SECOND: return ((longlong) seconds) * neg; case INTERVAL_MICROSECOND: /* In MySQL difference between any two valid datetime values in microseconds fits into longlong. */ return ((longlong) ((ulonglong) seconds * 1000000L + microseconds)) * neg; default: break; } null_date: null_value=1; return 0; } void Item_func_timestamp_diff::print(String *str, enum_query_type query_type) { str->append(func_name()); str->append('('); switch (int_type) { case INTERVAL_YEAR: str->append(STRING_WITH_LEN("YEAR")); break; case INTERVAL_QUARTER: str->append(STRING_WITH_LEN("QUARTER")); break; case INTERVAL_MONTH: str->append(STRING_WITH_LEN("MONTH")); break; case INTERVAL_WEEK: str->append(STRING_WITH_LEN("WEEK")); break; case INTERVAL_DAY: str->append(STRING_WITH_LEN("DAY")); break; case INTERVAL_HOUR: str->append(STRING_WITH_LEN("HOUR")); break; case INTERVAL_MINUTE: str->append(STRING_WITH_LEN("MINUTE")); break; case INTERVAL_SECOND: str->append(STRING_WITH_LEN("SECOND")); break; case INTERVAL_MICROSECOND: str->append(STRING_WITH_LEN("MICROSECOND")); break; default: break; } for (uint i=0 ; i < 2 ; i++) { str->append(','); args[i]->print(str, query_type); } str->append(')'); } String *Item_func_get_format::val_str_ascii(String *str) { DBUG_ASSERT(fixed == 1); const char *format_name; KNOWN_DATE_TIME_FORMAT *format; String *val= args[0]->val_str_ascii(str); ulong val_len; if ((null_value= args[0]->null_value)) return 0; val_len= val->length(); for (format= &known_date_time_formats[0]; (format_name= format->format_name); format++) { uint format_name_len; format_name_len= (uint) strlen(format_name); if (val_len == format_name_len && !my_charset_latin1.strnncoll(val->ptr(), val_len, format_name, val_len)) { const char *format_str= get_date_time_format_str(format, type); str->set(format_str, (uint) strlen(format_str), &my_charset_numeric); return str; } } null_value= 1; return 0; } void Item_func_get_format::print(String *str, enum_query_type query_type) { str->append(func_name()); str->append('('); switch (type) { case MYSQL_TIMESTAMP_DATE: str->append(STRING_WITH_LEN("DATE, ")); break; case MYSQL_TIMESTAMP_DATETIME: str->append(STRING_WITH_LEN("DATETIME, ")); break; case MYSQL_TIMESTAMP_TIME: str->append(STRING_WITH_LEN("TIME, ")); break; default: DBUG_ASSERT(0); } args[0]->print(str, query_type); str->append(')'); } /** Get type of datetime value (DATE/TIME/...) which will be produced according to format string. @param format format string @param length length of format string @note We don't process day format's characters('D', 'd', 'e') because day may be a member of all date/time types. @note Format specifiers supported by this function should be in sync with specifiers supported by extract_date_time() function. @return A function handler corresponding the given format */ static const Item_handled_func::Handler * get_date_time_result_type(const char *format, uint length) { const char *time_part_frms= "HISThiklrs"; const char *date_part_frms= "MVUXYWabcjmvuxyw"; bool date_part_used= 0, time_part_used= 0, frac_second_used= 0; const char *val= format; const char *end= format + length; for (; val != end; val++) { if (*val == '%' && val+1 != end) { val++; if (*val == 'f') frac_second_used= time_part_used= 1; else if (!time_part_used && strchr(time_part_frms, *val)) time_part_used= 1; else if (!date_part_used && strchr(date_part_frms, *val)) date_part_used= 1; if (date_part_used && frac_second_used) { /* frac_second_used implies time_part_used, and thus we already have all types of date-time components and can end our search. */ return &func_handler_str_to_date_datetime_usec; } } } /* We don't have all three types of date-time components */ if (frac_second_used) return &func_handler_str_to_date_time_usec; if (time_part_used) { if (date_part_used) return &func_handler_str_to_date_datetime_sec; return &func_handler_str_to_date_time_sec; } return &func_handler_str_to_date_date; } bool Item_func_str_to_date::fix_length_and_dec() { if (!args[0]->type_handler()->is_traditional_scalar_type() || !args[1]->type_handler()->is_traditional_scalar_type()) { my_error(ER_ILLEGAL_PARAMETER_DATA_TYPES2_FOR_OPERATION, MYF(0), args[0]->type_handler()->name().ptr(), args[1]->type_handler()->name().ptr(), func_name()); return TRUE; } if (agg_arg_charsets(collation, args, 2, MY_COLL_ALLOW_CONV, 1)) return TRUE; if (collation.collation->mbminlen > 1) internal_charset= &my_charset_utf8mb4_general_ci; maybe_null= true; set_func_handler(&func_handler_str_to_date_datetime_usec); if ((const_item= args[1]->const_item())) { StringBuffer<64> format_str; String *format= args[1]->val_str(&format_str, &format_converter, internal_charset); if (!args[1]->null_value) set_func_handler(get_date_time_result_type(format->ptr(), format->length())); } return m_func_handler->fix_length_and_dec(this); } bool Item_func_str_to_date::get_date_common(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate, timestamp_type tstype) { DATE_TIME_FORMAT date_time_format; StringBuffer<64> val_string, format_str; String *val, *format; val= args[0]->val_str(&val_string, &subject_converter, internal_charset); format= args[1]->val_str(&format_str, &format_converter, internal_charset); if (args[0]->null_value || args[1]->null_value) return (null_value=1); date_time_format.format.str= (char*) format->ptr(); date_time_format.format.length= format->length(); if (extract_date_time(thd, &date_time_format, val->ptr(), val->length(), ltime, tstype, 0, "datetime", date_conv_mode_t(fuzzydate) | sql_mode_for_dates(thd))) return (null_value=1); return (null_value= 0); } bool Item_func_last_day::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) { Datetime::Options opt(date_conv_mode_t(fuzzydate & ~TIME_TIME_ONLY), time_round_mode_t(fuzzydate)); Datetime *d= new(ltime) Datetime(thd, args[0], opt); if ((null_value= (!d->is_valid_datetime() || ltime->month == 0))) return true; uint month_idx= ltime->month-1; ltime->day= days_in_month[month_idx]; if ( month_idx == 1 && calc_days_in_year(ltime->year) == 366) ltime->day= 29; ltime->hour= ltime->minute= ltime->second= 0; ltime->second_part= 0; ltime->time_type= MYSQL_TIMESTAMP_DATE; return (null_value= 0); }