summaryrefslogtreecommitdiffstats
path: root/sql/item_timefunc.cc
diff options
context:
space:
mode:
Diffstat (limited to 'sql/item_timefunc.cc')
-rw-r--r--sql/item_timefunc.cc3911
1 files changed, 3911 insertions, 0 deletions
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
new file mode 100644
index 00000000..b624a381
--- /dev/null
+++ b/sql/item_timefunc.cc
@@ -0,0 +1,3911 @@
+/*
+ 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 <m_ctype.h>
+#include <time.h>
+
+/** 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 uchar *ptr, *end;
+
+ str->length(0);
+
+ if (l_time->neg)
+ str->append_wc('-');
+
+ end= (ptr= (const uchar *) format->ptr()) + format->length();
+
+ for ( ; ; )
+ {
+ my_wc_t wc;
+ int mblen= format->charset()->cset->mb_wc(format->charset(), &wc, ptr, end);
+ if (mblen < 1)
+ return false;
+ ptr+= mblen;
+
+ if (wc != '%' || ptr >= end)
+ str->append_wc(wc);
+ else
+ {
+ mblen= format->charset()->cset->mb_wc(format->charset(), &wc, ptr, end);
+ if (mblen < 1)
+ return false;
+ ptr+= mblen;
+
+ switch (wc) {
+ 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;
+ str->append_zerofill(l_time->day, 1);
+ 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;
+ str->append_zerofill(l_time->year, 4);
+ break;
+ case 'y':
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ str->append_zerofill(l_time->year % 100, 2);
+ break;
+ case 'm':
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ str->append_zerofill(l_time->month, 2);
+ break;
+ case 'c':
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ str->append_zerofill(l_time->month, 1);
+ break;
+ case 'd':
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ str->append_zerofill(l_time->day, 2);
+ break;
+ case 'e':
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ str->append_zerofill(l_time->day, 1);
+ break;
+ case 'f':
+ str->append_zerofill((uint) l_time->second_part, 6);
+ break;
+ case 'H':
+ str->append_zerofill(l_time->hour, 2);
+ break;
+ case 'h':
+ case 'I':
+ hours_i= (l_time->hour%24 + 11)%12+1;
+ str->append_zerofill(hours_i, 2);
+ break;
+ case 'i': /* minutes */
+ str->append_zerofill(l_time->minute, 2);
+ break;
+ case 'j':
+ {
+ if (type == MYSQL_TIMESTAMP_TIME || !l_time->month || !l_time->year)
+ return 1;
+ long value= calc_daynr(l_time->year,l_time->month, l_time->day) -
+ calc_daynr(l_time->year,1,1) + 1;
+ str->append_zerofill((uint) value, 3);
+ break;
+ }
+ case 'k':
+ str->append_zerofill(l_time->hour, 1);
+ break;
+ case 'l':
+ hours_i= (l_time->hour%24 + 11)%12+1;
+ str->append_zerofill(hours_i, 1);
+ 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':
+ str->append_zerofill(l_time->second, 2);
+ 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;
+
+ uint value= calc_week(l_time,
+ wc == 'U' ? WEEK_FIRST_WEEKDAY :
+ WEEK_MONDAY_FIRST,
+ &year);
+ str->append_zerofill(value, 2);
+ }
+ break;
+ case 'v':
+ case 'V':
+ {
+ uint year;
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ uint value= calc_week(l_time, wc == 'V' ?
+ (WEEK_YEAR | WEEK_FIRST_WEEKDAY) :
+ (WEEK_YEAR | WEEK_MONDAY_FIRST),
+ &year);
+ str->append_zerofill(value, 2);
+ }
+ break;
+ case 'x':
+ case 'X':
+ {
+ uint year;
+ if (type == MYSQL_TIMESTAMP_TIME)
+ return 1;
+ (void) calc_week(l_time,
+ (wc == 'X' ?
+ WEEK_YEAR | WEEK_FIRST_WEEKDAY :
+ WEEK_YEAR | WEEK_MONDAY_FIRST),
+ &year);
+ str->append_zerofill(year, 4);
+ }
+ 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);
+ str->append_zerofill(weekday, 1);
+ break;
+
+ default:
+ str->append_wc(wc);
+ 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());
+ 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());
+ 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());
+ 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());
+ // 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());
+ 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());
+ // 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 &ltime= 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());
+ 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());
+ 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());
+ 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)
+{
+ 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;
+ set_maybe_null();
+ return FALSE;
+}
+
+
+String* Item_func_monthname::val_str(String* str)
+{
+ DBUG_ASSERT(fixed());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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());
+ 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)
+{
+ 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;
+ set_maybe_null();
+ return FALSE;
+}
+
+
+String* Item_func_dayname::val_str(String* str)
+{
+ DBUG_ASSERT(fixed());
+ 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());
+ 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());
+ // 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 &ltime= 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());
+ 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());
+ 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());
+ 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());
+ 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, &ltime->year, &ltime->month,
+ &ltime->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->used |= THD::TIME_ZONE_USED;
+}
+
+
+/**
+ 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, &ltime);
+ /* 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),
+ 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, &ltime);
+ }
+ *res= ltime;
+ return 0;
+}
+
+void Item_func_curtime::print(String *str, enum_query_type query_type)
+{
+ str->append(func_name_cstring());
+ 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->used|= THD::TIME_ZONE_USED;
+}
+
+
+/**
+ 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),
+ 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_cstring());
+ 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->used|= THD::TIME_ZONE_USED;
+}
+
+
+/**
+ 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, &ltime);
+ }
+ *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->used|= THD::TIME_ZONE_USED;
+}
+
+
+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());
+ 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)
+{
+ 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<STRING_BUFFER_USUAL_SIZE> 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);
+ }
+ set_maybe_null(); // 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());
+ 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;
+}
+
+/*
+ Oracle has many formatting models, we list all but only part of them
+ are implemented, because some models depend on oracle functions
+ which mariadb is not supported.
+
+ Models for datetime, used by TO_CHAR/TO_DATE. Normal format characters are
+ stored as short integer < 128, while format characters are stored as a
+ integer > 128
+*/
+
+enum enum_tochar_formats
+{
+ FMT_BASE= 128,
+ FMT_AD,
+ FMT_AD_DOT,
+ FMT_AM,
+ FMT_AM_DOT,
+ FMT_BC,
+ FMT_BC_DOT,
+ FMT_CC,
+ FMT_SCC,
+ FMT_D,
+ FMT_DAY,
+ FMT_DD,
+ FMT_DDD,
+ FMT_DL,
+ FMT_DS,
+ FMT_DY,
+ FMT_E,
+ FMT_EE,
+ FMT_FF,
+ FMT_FM,
+ FMT_FX,
+ FMT_HH,
+ FMT_HH12,
+ FMT_HH24,
+ FMT_IW,
+ FMT_I,
+ FMT_IY,
+ FMT_IYY,
+ FMT_IYYY,
+ FMT_J,
+ FMT_MI,
+ FMT_MM,
+ FMT_MON,
+ FMT_MONTH,
+ FMT_PM,
+ FMT_PM_DOT,
+ FMT_RM,
+ FMT_RR,
+ FMT_RRRR,
+ FMT_SS,
+ FMT_SSSSSS,
+ FMT_TS,
+ FMT_TZD,
+ FMT_TZH,
+ FMT_TZM,
+ FMT_TZR,
+ FMT_W,
+ FMT_WW,
+ FMT_X,
+ FMT_Y,
+ FMT_YY,
+ FMT_YYY,
+ FMT_YYYY,
+ FMT_YYYY_COMMA,
+ FMT_YEAR,
+ FMT_SYYYY,
+ FMT_SYEAR
+};
+
+/**
+ Flip 'quotation_flag' if we found a quote (") character.
+
+ @param cftm Character or FMT... format descriptor
+ @param quotation_flag Points to 'true' if we are inside a quoted string
+
+ @return true If we are inside a quoted string or if we found a '"' character
+ @return false Otherwise
+*/
+
+static inline bool check_quotation(uint16 cfmt, bool *quotation_flag)
+{
+ if (cfmt == '"')
+ {
+ *quotation_flag= !*quotation_flag;
+ return true;
+ }
+ return *quotation_flag;
+}
+
+#define INVALID_CHARACTER(x) (((x) >= 'A' && (x) <= 'Z') ||((x) >= '0' && (x) <= '9') || (x) >= 127 || ((x) < 32))
+
+
+/**
+ Special characters are directly output in the result
+
+ @return 0 If found not acceptable character
+ @return # Number of copied characters
+*/
+
+static uint parse_special(char cfmt, const char *ptr, const char *end,
+ uint16 *array)
+{
+ int offset= 0;
+ char tmp1;
+
+ /* Non-printable character and Multibyte encoded characters */
+ if (INVALID_CHARACTER(cfmt))
+ return 0;
+
+ /*
+ * '&' with text is used for variable input, but '&' with other
+ * special charaters like '|'. '*' is used as separator
+ */
+ if (cfmt == '&' && ptr + 1 < end)
+ {
+ tmp1= my_toupper(system_charset_info, *(ptr+1));
+ if (tmp1 >= 'A' && tmp1 <= 'Z')
+ return 0;
+ }
+
+ do {
+ /*
+ Continuously store the special characters in fmt_array until non-special
+ characters appear
+ */
+ *array++= (uint16) (uchar) *ptr++;
+ offset++;
+ if (ptr == end)
+ break;
+ tmp1= my_toupper(system_charset_info, *ptr);
+ } while (!INVALID_CHARACTER(tmp1) && tmp1 != '"');
+ return offset;
+}
+
+
+/**
+ Parse the format string, convert it to an compact array and calculate the
+ length of output string
+
+ @param format Format string
+ @param fmt_len Function will store max length of formated date string here
+
+ @return 0 ok. fmt_len is updated
+ @return 1 error. In this case 'warning_string' is set to error message
+*/
+
+bool Item_func_tochar::parse_format_string(const String *format, uint *fmt_len)
+{
+ const char *ptr, *end;
+ uint16 *tmp_fmt= fmt_array;
+ uint tmp_len= 0;
+ int offset= 0;
+ bool quotation_flag= false;
+
+ ptr= format->ptr();
+ end= ptr + format->length();
+
+ if (format->length() > MAX_DATETIME_FORMAT_MODEL_LEN)
+ {
+ warning_message.append(STRING_WITH_LEN("datetime format string is too "
+ "long"));
+ return 1;
+ }
+
+ for (; ptr < end; ptr++, tmp_fmt++)
+ {
+ uint ulen;
+ char cfmt, next_char;
+
+ cfmt= my_toupper(system_charset_info, *ptr);
+
+ /*
+ Oracle datetime format support text in double quotation marks like
+ 'YYYY"abc"MM"xyz"DD', When this happens, store the text and quotation
+ marks, and use the text as a separator in make_date_time_oracle.
+
+ NOTE: the quotation mark is not print in return value. for example:
+ select TO_CHAR(sysdate, 'YYYY"abc"MM"xyzDD"') will return 2021abc01xyz11
+ */
+ if (check_quotation(cfmt, &quotation_flag))
+ {
+ *tmp_fmt= *ptr;
+ tmp_len+= 1;
+ continue;
+ }
+
+ switch (cfmt) {
+ case 'A': // AD/A.D./AM/A.M.
+ if (ptr+1 >= end)
+ goto error;
+ next_char= my_toupper(system_charset_info, *(ptr+1));
+ if (next_char == 'D')
+ {
+ *tmp_fmt= FMT_AD;
+ ptr+= 1;
+ tmp_len+= 2;
+ }
+ else if (next_char == 'M')
+ {
+ *tmp_fmt= FMT_AM;
+ ptr+= 1;
+ tmp_len+= 2;
+ }
+ else if (next_char == '.' && ptr+3 < end && *(ptr+3) == '.')
+ {
+ if (my_toupper(system_charset_info, *(ptr+2)) == 'D')
+ {
+ *tmp_fmt= FMT_AD_DOT;
+ ptr+= 3;
+ tmp_len+= 4;
+ }
+ else if (my_toupper(system_charset_info, *(ptr+2)) == 'M')
+ {
+ *tmp_fmt= FMT_AM_DOT;
+ ptr+= 3;
+ tmp_len+= 4;
+ }
+ else
+ goto error;
+ }
+ else
+ goto error;
+ break;
+ case 'B': // BC and B.C
+ if (ptr+1 >= end)
+ goto error;
+ next_char= my_toupper(system_charset_info, *(ptr+1));
+ if (next_char == 'C')
+ {
+ *tmp_fmt= FMT_BC;
+ ptr+= 1;
+ tmp_len+= 2;
+ }
+ else if (next_char == '.' && ptr+3 < end &&
+ my_toupper(system_charset_info, *(ptr+2)) == 'C' &&
+ *(ptr+3) == '.')
+ {
+ *tmp_fmt= FMT_BC_DOT;
+ ptr+= 3;
+ tmp_len+= 4;
+ }
+ else
+ goto error;
+ break;
+ case 'P': // PM or P.M.
+ next_char= my_toupper(system_charset_info, *(ptr+1));
+ if (next_char == 'M')
+ {
+ *tmp_fmt= FMT_PM;
+ ptr+= 1;
+ tmp_len+= 2;
+ }
+ else if (next_char == '.' &&
+ my_toupper(system_charset_info, *(ptr+2)) == 'M' &&
+ my_toupper(system_charset_info, *(ptr+3)) == '.')
+ {
+ *tmp_fmt= FMT_PM_DOT;
+ ptr+= 3;
+ tmp_len+= 4;
+ }
+ else
+ goto error;
+ break;
+ case 'Y': // Y, YY, YYY o YYYYY
+ if (ptr + 1 == end || my_toupper(system_charset_info, *(ptr+1)) != 'Y')
+ {
+ *tmp_fmt= FMT_Y;
+ tmp_len+= 1;
+ break;
+ }
+ if (ptr + 2 == end ||
+ my_toupper(system_charset_info, *(ptr+2)) != 'Y') /* YY */
+ {
+ *tmp_fmt= FMT_YY;
+ ulen= 2;
+ }
+ else
+ {
+ if (ptr + 3 < end && my_toupper(system_charset_info, *(ptr+3)) == 'Y')
+ {
+ *tmp_fmt= FMT_YYYY;
+ ulen= 4;
+ }
+ else
+ {
+ *tmp_fmt= FMT_YYY;
+ ulen= 3;
+ }
+ }
+ ptr+= ulen-1;
+ tmp_len+= ulen;
+ break;
+
+ case 'R': // RR or RRRR
+ if (ptr + 1 == end || my_toupper(system_charset_info, *(ptr+1)) != 'R')
+ goto error;
+
+ if (ptr + 2 == end || my_toupper(system_charset_info, *(ptr+2)) != 'R')
+ {
+ *tmp_fmt= FMT_RR;
+ ulen= 2;
+ }
+ else
+ {
+ if (ptr + 3 >= end || my_toupper(system_charset_info, *(ptr+3)) != 'R')
+ goto error;
+ *tmp_fmt= FMT_RRRR;
+ ulen= 4;
+ }
+ ptr+= ulen-1;
+ tmp_len+= ulen;
+ break;
+ case 'M':
+ {
+ char tmp1;
+ if (ptr + 1 >= end)
+ goto error;
+
+ tmp1= my_toupper(system_charset_info, *(ptr+1));
+ if (tmp1 == 'M')
+ {
+ *tmp_fmt= FMT_MM;
+ tmp_len+= 2;
+ ptr+= 1;
+ }
+ else if (tmp1 == 'I')
+ {
+ *tmp_fmt= FMT_MI;
+ tmp_len+= 2;
+ ptr+= 1;
+ }
+ else if (tmp1 == 'O')
+ {
+ if (ptr + 2 >= end)
+ goto error;
+ char tmp2= my_toupper(system_charset_info, *(ptr+2));
+ if (tmp2 != 'N')
+ goto error;
+
+ if (ptr + 4 >= end ||
+ my_toupper(system_charset_info, *(ptr+3)) != 'T' ||
+ my_toupper(system_charset_info, *(ptr+4)) != 'H')
+ {
+ *tmp_fmt= FMT_MON;
+ tmp_len+= 3;
+ ptr+= 2;
+ }
+ else
+ {
+ *tmp_fmt= FMT_MONTH;
+ tmp_len+= (locale->max_month_name_length *
+ my_charset_utf8mb3_bin.mbmaxlen);
+ ptr+= 4;
+ }
+ }
+ else
+ goto error;
+ }
+ break;
+ case 'D': // DD, DY, or DAY
+ {
+ if (ptr + 1 >= end)
+ goto error;
+ char tmp1= my_toupper(system_charset_info, *(ptr+1));
+
+ if (tmp1 == 'D')
+ {
+ *tmp_fmt= FMT_DD;
+ tmp_len+= 2;
+ }
+ else if (tmp1 == 'Y')
+ {
+ *tmp_fmt= FMT_DY;
+ tmp_len+= 3;
+ }
+ else if (tmp1 == 'A') // DAY
+ {
+ if (ptr + 2 == end || my_toupper(system_charset_info, *(ptr+2)) != 'Y')
+ goto error;
+ *tmp_fmt= FMT_DAY;
+ tmp_len+= locale->max_day_name_length * my_charset_utf8mb3_bin.mbmaxlen;
+ ptr+= 1;
+ }
+ else
+ goto error;
+ ptr+= 1;
+ }
+ break;
+ case 'H': // HH, HH12 or HH23
+ {
+ char tmp1, tmp2, tmp3;
+ if (ptr + 1 >= end)
+ goto error;
+ tmp1= my_toupper(system_charset_info, *(ptr+1));
+
+ if (tmp1 != 'H')
+ goto error;
+
+ if (ptr+3 >= end)
+ {
+ *tmp_fmt= FMT_HH;
+ ptr+= 1;
+ }
+ else
+ {
+ tmp2= *(ptr+2);
+ tmp3= *(ptr+3);
+
+ if (tmp2 == '1' && tmp3 == '2')
+ {
+ *tmp_fmt= FMT_HH12;
+ ptr+= 3;
+ }
+ else if (tmp2 == '2' && tmp3 == '4')
+ {
+ *tmp_fmt= FMT_HH24;
+ ptr+= 3;
+ }
+ else
+ {
+ *tmp_fmt= FMT_HH;
+ ptr+= 1;
+ }
+ }
+ tmp_len+= 2;
+ break;
+ }
+ case 'S': // SS
+ if (ptr + 1 == end || my_toupper(system_charset_info, *(ptr+1)) != 'S')
+ goto error;
+
+ *tmp_fmt= FMT_SS;
+ tmp_len+= 2;
+ ptr+= 1;
+ break;
+ case '|':
+ /*
+ If only one '|' just ignore it, else append others, for example:
+ TO_CHAR('2000-11-05', 'YYYY|MM||||DD') --> 200011|||05
+ */
+ if (ptr + 1 == end || *(ptr+1) != '|')
+ {
+ tmp_fmt--;
+ break;
+ }
+ ptr++; // Skip first '|'
+ do
+ {
+ *tmp_fmt++= *ptr++;
+ tmp_len++;
+ } while ((ptr < end) && *ptr == '|');
+ ptr--; // Fix ptr for above for loop
+ tmp_fmt--;
+ break;
+
+ default:
+ offset= parse_special(cfmt, ptr, end, tmp_fmt);
+ if (!offset)
+ goto error;
+ /* ptr++ is in the for loop, so we must move ptr to offset-1 */
+ ptr+= (offset-1);
+ tmp_fmt+= (offset-1);
+ tmp_len+= offset;
+ break;
+ }
+ }
+ *fmt_len= tmp_len;
+ *tmp_fmt= 0;
+ return 0;
+
+error:
+ warning_message.append(STRING_WITH_LEN("date format not recognized at "));
+ warning_message.append(ptr, MY_MIN(8, end- ptr));
+ return 1;
+}
+
+
+static inline bool append_val(int val, int size, String *str)
+{
+ return str->append_zerofill(val, size);
+}
+
+
+static bool make_date_time_oracle(const uint16 *fmt_array,
+ const MYSQL_TIME *l_time,
+ const MY_LOCALE *locale,
+ String *str)
+{
+ bool quotation_flag= false;
+ const uint16 *ptr= fmt_array;
+ uint hours_i;
+ uint weekday;
+
+ str->length(0);
+
+ while (*ptr)
+ {
+ if (check_quotation(*ptr, &quotation_flag))
+ {
+ /* don't display '"' in the result, so if it is '"', skip it */
+ if (*ptr != '"')
+ {
+ DBUG_ASSERT(*ptr <= 255);
+ str->append((char) *ptr);
+ }
+ ptr++;
+ continue;
+ }
+
+ switch (*ptr) {
+
+ case FMT_AM:
+ case FMT_PM:
+ if (l_time->hour > 11)
+ str->append("PM", 2);
+ else
+ str->append("AM", 2);
+ break;
+
+ case FMT_AM_DOT:
+ case FMT_PM_DOT:
+ if (l_time->hour > 11)
+ str->append(STRING_WITH_LEN("P.M."));
+ else
+ str->append(STRING_WITH_LEN("A.M."));
+ break;
+
+ case FMT_AD:
+ case FMT_BC:
+ if (l_time->year > 0)
+ str->append(STRING_WITH_LEN("AD"));
+ else
+ str->append(STRING_WITH_LEN("BC"));
+ break;
+
+ case FMT_AD_DOT:
+ case FMT_BC_DOT:
+ if (l_time->year > 0)
+ str->append(STRING_WITH_LEN("A.D."));
+ else
+ str->append(STRING_WITH_LEN("B.C."));
+ break;
+
+ case FMT_Y:
+ if (append_val(l_time->year%10, 1, str))
+ goto err_exit;
+ break;
+
+ case FMT_YY:
+ case FMT_RR:
+ if (append_val(l_time->year%100, 2, str))
+ goto err_exit;
+ break;
+
+ case FMT_YYY:
+ if (append_val(l_time->year%1000, 3, str))
+ goto err_exit;
+ break;
+
+ case FMT_YYYY:
+ case FMT_RRRR:
+ if (append_val(l_time->year, 4, str))
+ goto err_exit;
+ break;
+
+ case FMT_MM:
+ if (append_val(l_time->month, 2, str))
+ goto err_exit;
+ break;
+
+ case FMT_MON:
+ {
+ if (l_time->month == 0)
+ {
+ str->append("00", 2);
+ }
+ else
+ {
+ const char *month_name= (locale->ab_month_names->
+ type_names[l_time->month-1]);
+ size_t m_len= strlen(month_name);
+ str->append(month_name, m_len, system_charset_info);
+ }
+ }
+ break;
+
+ case FMT_MONTH:
+ {
+ if (l_time->month == 0)
+ {
+ str->append("00", 2);
+ }
+ else
+ {
+ const char *month_name= (locale->month_names->
+ type_names[l_time->month-1]);
+ size_t month_byte_len= strlen(month_name);
+ size_t month_char_len;
+ str->append(month_name, month_byte_len, system_charset_info);
+ month_char_len= my_numchars_mb(&my_charset_utf8mb3_general_ci,
+ month_name, month_name +
+ month_byte_len);
+ if (str->fill(str->length() + locale->max_month_name_length -
+ month_char_len, ' '))
+ goto err_exit;
+ }
+ }
+ break;
+
+ case FMT_DD:
+ if (append_val(l_time->day, 2, str))
+ goto err_exit;
+ break;
+
+ case FMT_DY:
+ {
+ if (l_time->day == 0)
+ str->append("00", 2);
+ else
+ {
+ weekday= calc_weekday(calc_daynr(l_time->year,l_time->month,
+ l_time->day), 0);
+ const char *day_name= locale->ab_day_names->type_names[weekday];
+ str->append(day_name, strlen(day_name), system_charset_info);
+ }
+ }
+ break;
+
+ case FMT_DAY:
+ {
+ if (l_time->day == 0)
+ str->append("00", 2, system_charset_info);
+ else
+ {
+ const char *day_name;
+ size_t day_byte_len, day_char_len;
+ weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
+ l_time->day), 0);
+ day_name= locale->day_names->type_names[weekday];
+ day_byte_len= strlen(day_name);
+ str->append(day_name, day_byte_len, system_charset_info);
+ day_char_len= my_numchars_mb(&my_charset_utf8mb3_general_ci,
+ day_name, day_name + day_byte_len);
+ if (str->fill(str->length() + locale->max_day_name_length -
+ day_char_len, ' '))
+ goto err_exit;
+ }
+ }
+ break;
+
+ case FMT_HH12:
+ case FMT_HH:
+ hours_i= (l_time->hour%24 + 11)%12+1;
+ if (append_val(hours_i, 2, str))
+ goto err_exit;
+ break;
+
+ case FMT_HH24:
+ if (append_val(l_time->hour, 2, str))
+ goto err_exit;
+ break;
+
+ case FMT_MI:
+ if (append_val(l_time->minute, 2, str))
+ goto err_exit;
+ break;
+
+ case FMT_SS:
+ if (append_val(l_time->second, 2, str))
+ goto err_exit;
+ break;
+
+ default:
+ str->append((char) *ptr);
+ }
+
+ ptr++;
+ };
+ return false;
+
+err_exit:
+ return true;
+}
+
+
+bool Item_func_tochar::fix_length_and_dec(THD *thd)
+{
+ CHARSET_INFO *cs= thd->variables.collation_connection;
+ Item *arg1= args[1]->this_item();
+ my_repertoire_t repertoire= arg1->collation.repertoire;
+ StringBuffer<STRING_BUFFER_USUAL_SIZE> buffer;
+ String *str;
+
+ locale= thd->variables.lc_time_names;
+ if (!thd->variables.lc_time_names->is_ascii)
+ repertoire|= MY_REPERTOIRE_EXTENDED;
+ collation.set(cs, arg1->collation.derivation, repertoire);
+
+ /* first argument must be datetime or string */
+ enum_field_types arg0_mysql_type= args[0]->field_type();
+
+ max_length= 0;
+ switch (arg0_mysql_type) {
+ case MYSQL_TYPE_TIME:
+ case MYSQL_TYPE_DATE:
+ case MYSQL_TYPE_DATETIME:
+ case MYSQL_TYPE_TIMESTAMP:
+ case MYSQL_TYPE_VARCHAR:
+ case MYSQL_TYPE_STRING:
+ break;
+ default:
+ {
+ my_printf_error(ER_STD_INVALID_ARGUMENT,
+ ER(ER_STD_INVALID_ARGUMENT),
+ MYF(0),
+ "data type of first argument must be type "
+ "date/datetime/time or string",
+ func_name());
+ return TRUE;
+ }
+ }
+ if (args[1]->basic_const_item() && (str= args[1]->val_str(&buffer)))
+ {
+ uint ulen;
+ fixed_length= 1;
+ if (parse_format_string(str, &ulen))
+ {
+ my_printf_error(ER_STD_INVALID_ARGUMENT,
+ ER(ER_STD_INVALID_ARGUMENT),
+ MYF(0),
+ warning_message.c_ptr(),
+ func_name());
+ return TRUE;
+ }
+ max_length= (uint32) (ulen * collation.collation->mbmaxlen);
+ }
+ else
+ {
+ fixed_length= 0;
+ max_length= (uint32) MY_MIN(arg1->max_length * 10 *
+ collation.collation->mbmaxlen,
+ MAX_BLOB_WIDTH);
+ }
+ set_maybe_null();
+ return FALSE;
+}
+
+
+String *Item_func_tochar::val_str(String* str)
+ {
+ THD *thd= current_thd;
+ StringBuffer<64> format_buffer;
+ String *format;
+ MYSQL_TIME l_time;
+ const MY_LOCALE *lc= locale;
+ date_conv_mode_t mode= TIME_CONV_NONE;
+ size_t max_result_length= max_length;
+
+ if (warning_message.length())
+ goto null_date;
+
+ if ((null_value= args[0]->get_date(thd, &l_time,
+ Temporal::Options(mode, thd))))
+ return 0;
+
+ if (!fixed_length)
+ {
+ uint ulen;
+ if (!(format= args[1]->val_str(&format_buffer)) || !format->length() ||
+ parse_format_string(format, &ulen))
+ goto null_date;
+ max_result_length= ((size_t) ulen) * collation.collation->mbmaxlen;
+ }
+
+ if (str->alloc(max_result_length))
+ goto null_date;
+
+ /* Create the result string */
+ str->set_charset(collation.collation);
+ if (!make_date_time_oracle(fmt_array, &l_time, lc, str))
+ return str;
+
+null_date:
+
+ if (warning_message.length())
+ {
+ push_warning_printf(thd,
+ Sql_condition::WARN_LEVEL_WARN,
+ ER_STD_INVALID_ARGUMENT,
+ ER_THD(thd, ER_STD_INVALID_ARGUMENT),
+ warning_message.c_ptr(),
+ func_name());
+ if (!fixed_length)
+ warning_message.length(0);
+ }
+
+ null_value= 1;
+ return 0;
+}
+
+
+bool Item_func_from_unixtime::fix_length_and_dec(THD *thd)
+{
+ thd->used|= THD::TIME_ZONE_USED;
+ tz= thd->variables.time_zone;
+ Type_std_attributes::set(
+ Type_temporal_attributes_not_fixed_dec(MAX_DATETIME_WIDTH,
+ args[0]->decimals, false),
+ DTCollation_numeric());
+ set_maybe_null();
+ 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, &not_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(THD *thd)
+{
+ 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);
+ }
+ set_maybe_null();
+ 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);
+ static LEX_CSTRING minus_interval= { STRING_WITH_LEN(" - interval ") };
+ static LEX_CSTRING plus_interval= { STRING_WITH_LEN(" + interval ") };
+ LEX_CSTRING *tmp= date_sub_interval ? &minus_interval : &plus_interval;
+ str->append(tmp);
+ args[1]->print(str, query_type);
+ str->append(' ');
+ str->append(interval_names[int_type], strlen(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], strlen(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(THD *thd)
+{
+ set_maybe_null(); // 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());
+ 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('(');
+ size_t length= (size_t) (longlong10_to_str(decimals, buf, -10) - buf);
+ str->append(buf, length);
+ 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)
+ {
+ char buf[20];
+ size_t length= (size_t) (longlong10_to_str(cast_length, buf, 10) - buf);
+ str->append('(');
+ str->append(buf, length);
+ str->append(')');
+ }
+ if (cast_cs)
+ {
+ str->append(STRING_WITH_LEN(" charset "));
+ str->append(cast_cs->cs_name);
+ }
+ 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());
+ 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());
+ DBUG_ASSERT(cast_cs == &my_charset_bin);
+ NativeBuffer<STRING_BUFFER_USUAL_SIZE> 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<const Item_char_typecast*>(item));
+ return static_cast<Item_char_typecast*>(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;
+ if (current_thd->is_strict_mode())
+ set_maybe_null();
+}
+
+
+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()
+ if (current_thd->is_strict_mode())
+ set_maybe_null();
+}
+
+
+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());
+ 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, &ltime->year, &ltime->month, &ltime->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(THD *thd)
+{
+ 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);
+ }
+
+ set_maybe_null();
+ 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());
+ 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());
+ 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());
+ 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(&ltime1) ||
+ Datetime(thd, args[1], opt).copy_to_mysql_time(&ltime2))
+ goto null_date;
+
+ if (calc_time_diff(&ltime2,&ltime1, 1,
+ &seconds, &microseconds))
+ 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_cstring());
+ 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());
+ 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_cstring());
+ 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(THD *thd)
+{
+ 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;
+
+ set_maybe_null();
+ 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);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 13:35:41 +0000