mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 12:32:27 +01:00
07e4853c23
MDEV-17625 Different warnings when comparing a garbage to DATETIME vs TIME
- Splitting processes of data type conversion (to TIME/DATE,DATETIME)
and warning generation.
Warning are now only get collected during conversion (in an "int" variable),
and are pushed in the very end of conversion (not in parallel).
Warnings generated by the low level routines str_to_xxx() and number_to_xxx()
can now be changed at the end, when TIME_FUZZY_DATES is applied,
from "Invalid value" to "Truncated invalid value".
Now "Illegal value" is issued only when the low level routine returned
an error and TIME_FUZZY_DATES was not set. Otherwise, if the low level
routine returned "false" (success), or if NULL was converted to a zero
datetime by TIME_FUZZY_DATES, then "Truncated illegal value"
is issued. This gives better warnings.
- Methods Type_handler::Item_get_date() and
Type_handler::Item_func_hybrid_field_type_get_date() now only
convert and collect warning information, but do not push warnings.
- Changing the return data type for Type_handler::Item_get_date()
and Type_handler::Item_func_hybrid_field_type_get_date() from
"bool" to "void". The conversion result (success vs error) can be
checked by testing ltime->time_type. MYSQL_TIME_{NONE|ERROR}
mean mean error, other values mean success.
- Adding new wrapper methods Type_handler::Item_get_date_with_warn() and
Type_handler::Item_func_hybrid_field_type_get_date_with_warn()
to do conversion followed by raising warnings, and changing
the code to call new Type_handler::***_with_warn() methods.
- Adding a helper class Temporal::Status, a wrapper
for MYSQL_TIME_STATUS with automatic initialization.
- Adding a helper class Temporal::Warn, to collect warnings
but without actually raising them. Moving a part of ErrConv
into a separate class ErrBuff, and deriving both Temporal::Warn
and ErrConv from ErrBuff. The ErrBuff part of Temporal::Warn
is used to collect textual representation of the input data.
- Adding a helper class Temporal::Warn_push. It's used
to collect warning information during conversion, and
automatically pushes warnings to the diagnostics area
on its destructor time (in case of non-zero warning).
- Moving more code from various functions inside class Temporal.
- Adding more Temporal_hybrid constructors and
protected Temporal methods make_from_xxx(),
which convert and only collect warning information, but do not
actually raise warnings.
- Now the low level functions str_to_datetime() and str_to_time()
always set status->warning if the return value is "true" (error).
- Now the low level functions number_to_time() and number_to_datetime()
set the "*was_cut" argument if the return value is "true" (error).
- Adding a few DBUG_ASSERTs to make sure that str_to_xxx() and
number_to_xxx() always set warnings on error.
- Adding new warning flags MYSQL_TIME_WARN_EDOM and MYSQL_TIME_WARN_ZERO_DATE
for the code symmetry. Before this change there was a special
code path for (rc==true && was_cut==0) which was treated by
Field_temporal::store_invalid_with_warning as "zero date violation".
Now was_cut==0 always means that there are no any error/warnings/notes
to be raised, not matter what rc is.
- Using new Temporal_hybrid constructors in combination with
Temporal::Warn_push inside str_to_datetime_with_warn(),
double_to_datetime_with_warn(), int_to_datetime_with_warn(),
Field::get_date(), Item::get_date_from_string(), and a few other places.
- Removing methods Dec_ptr::to_datetime_with_warn(),
Year::to_time_with_warn(), my_decimal::to_datetime_with_warn(),
Dec_ptr::to_datetime_with_warn().
Fixing Sec6::to_time() and Sec6::to_datetime() to
convert and only collect warnings, without raising warnings.
Now warning raising functionality resides in Temporal::Warn_push.
- Adding classes Longlong_hybrid_null and Double_null, to
return both value and the "IS NULL" flag. Adding methods
Item::to_double_null(), to_longlong_hybrid_null(),
Item_func_hybrid_field_type::to_longlong_hybrid_null_op(),
Item_func_hybrid_field_type::to_double_null_op().
Removing separate classes VInt and VInt_op, as they
have been replaced by a single class Longlong_hybrid_null.
- Adding a helper method Temporal::type_name_by_timestamp_type(),
moving a part of make_truncated_value_warning() into it,
and reusing in Temporal::Warn::push_conversion_warnings().
- Removing Item::make_zero_date() and
Item_func_hybrid_field_type::make_zero_mysql_time().
They provided duplicate functionality.
Now this code resides in Temporal::make_fuzzy_date().
The latter is now called for all Item types when data type
conversion (to DATE/TIME/DATETIME) is involved, including
Item_field and Item_direct_view_ref.
This fixes MDEV-17563: Item_direct_view_ref now correctly converts
NULL to a zero date when TIME_FUZZY_DATES says so.
1744 lines
53 KiB
C++
1744 lines
53 KiB
C++
#ifndef ITEM_TIMEFUNC_INCLUDED
|
|
#define ITEM_TIMEFUNC_INCLUDED
|
|
/* Copyright (c) 2000, 2011, Oracle and/or its affiliates.
|
|
Copyright (c) 2009-2011, Monty Program Ab
|
|
|
|
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 Street, Fifth Floor, Boston, MA 02110-1301, USA */
|
|
|
|
|
|
/* Function items used by mysql */
|
|
|
|
#ifdef USE_PRAGMA_INTERFACE
|
|
#pragma interface /* gcc class implementation */
|
|
#endif
|
|
|
|
class MY_LOCALE;
|
|
|
|
|
|
bool get_interval_value(THD *thd, Item *args,
|
|
interval_type int_type, INTERVAL *interval);
|
|
|
|
|
|
class Item_long_func_date_field: public Item_long_func
|
|
{
|
|
bool check_arguments() const
|
|
{ return args[0]->check_type_can_return_date(func_name()); }
|
|
public:
|
|
Item_long_func_date_field(THD *thd, Item *a)
|
|
:Item_long_func(thd, a) { }
|
|
};
|
|
|
|
|
|
class Item_long_func_time_field: public Item_long_func
|
|
{
|
|
bool check_arguments() const
|
|
{ return args[0]->check_type_can_return_time(func_name()); }
|
|
public:
|
|
Item_long_func_time_field(THD *thd, Item *a)
|
|
:Item_long_func(thd, a) { }
|
|
};
|
|
|
|
|
|
class Item_func_period_add :public Item_long_func
|
|
{
|
|
bool check_arguments() const
|
|
{ return check_argument_types_can_return_int(0, 2); }
|
|
public:
|
|
Item_func_period_add(THD *thd, Item *a, Item *b): Item_long_func(thd, a, b) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "period_add"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
|
|
return FALSE;
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_period_add>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_period_diff :public Item_long_func
|
|
{
|
|
bool check_arguments() const
|
|
{ return check_argument_types_can_return_int(0, 2); }
|
|
public:
|
|
Item_func_period_diff(THD *thd, Item *a, Item *b): Item_long_func(thd, a, b) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "period_diff"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
|
|
return FALSE;
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_period_diff>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_to_days :public Item_long_func_date_field
|
|
{
|
|
public:
|
|
Item_func_to_days(THD *thd, Item *a): Item_long_func_date_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "to_days"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
enum_monotonicity_info get_monotonicity_info() const;
|
|
longlong val_int_endpoint(bool left_endp, bool *incl_endp);
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_to_days>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_to_seconds :public Item_longlong_func
|
|
{
|
|
bool check_arguments() const
|
|
{ return check_argument_types_can_return_date(0, arg_count); }
|
|
public:
|
|
Item_func_to_seconds(THD *thd, Item *a): Item_longlong_func(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "to_seconds"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
fix_char_length(12);
|
|
maybe_null= 1;
|
|
return FALSE;
|
|
}
|
|
enum_monotonicity_info get_monotonicity_info() const;
|
|
longlong val_int_endpoint(bool left_endp, bool *incl_endp);
|
|
bool check_partition_func_processor(void *bool_arg) { return FALSE;}
|
|
|
|
/* Only meaningful with date part and optional time part */
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_to_seconds>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_dayofmonth :public Item_long_func_date_field
|
|
{
|
|
public:
|
|
Item_func_dayofmonth(THD *thd, Item *a): Item_long_func_date_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "dayofmonth"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_dayofmonth>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_month :public Item_func
|
|
{
|
|
public:
|
|
Item_func_month(THD *thd, Item *a): Item_func(thd, a)
|
|
{ collation.set_numeric(); }
|
|
longlong val_int();
|
|
double val_real()
|
|
{ DBUG_ASSERT(fixed == 1); return (double) Item_func_month::val_int(); }
|
|
String *val_str(String *str)
|
|
{
|
|
longlong nr= val_int();
|
|
if (null_value)
|
|
return 0;
|
|
str->set(nr, collation.collation);
|
|
return str;
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
|
|
{
|
|
return get_date_from_int(thd, ltime, fuzzydate);
|
|
}
|
|
const char *func_name() const { return "month"; }
|
|
const Type_handler *type_handler() const { return &type_handler_long; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals= 0;
|
|
fix_char_length(2);
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_month>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_monthname :public Item_str_func
|
|
{
|
|
MY_LOCALE *locale;
|
|
public:
|
|
Item_func_monthname(THD *thd, Item *a): Item_str_func(thd, a) {}
|
|
const char *func_name() const { return "monthname"; }
|
|
String *val_str(String *str);
|
|
bool fix_length_and_dec();
|
|
bool check_partition_func_processor(void *int_arg) {return TRUE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_monthname>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_dayofyear :public Item_long_func_date_field
|
|
{
|
|
public:
|
|
Item_func_dayofyear(THD *thd, Item *a): Item_long_func_date_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "dayofyear"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals= 0;
|
|
fix_char_length(3);
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_dayofyear>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_hour :public Item_long_func_time_field
|
|
{
|
|
public:
|
|
Item_func_hour(THD *thd, Item *a): Item_long_func_time_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "hour"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_time_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_hour>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_minute :public Item_long_func_time_field
|
|
{
|
|
public:
|
|
Item_func_minute(THD *thd, Item *a): Item_long_func_time_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "minute"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_time_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_minute>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_quarter :public Item_long_func_date_field
|
|
{
|
|
public:
|
|
Item_func_quarter(THD *thd, Item *a): Item_long_func_date_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "quarter"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=1*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_quarter>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_second :public Item_long_func_time_field
|
|
{
|
|
public:
|
|
Item_func_second(THD *thd, Item *a): Item_long_func_time_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "second"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_time_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_second>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_week :public Item_long_func
|
|
{
|
|
bool check_arguments() const
|
|
{
|
|
return args[0]->check_type_can_return_date(func_name()) ||
|
|
(arg_count > 1 && args[1]->check_type_can_return_int(func_name()));
|
|
}
|
|
public:
|
|
Item_func_week(THD *thd, Item *a): Item_long_func(thd, a) {}
|
|
Item_func_week(THD *thd, Item *a, Item *b): Item_long_func(thd, a, b) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "week"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
if (arg_count == 2)
|
|
return FALSE;
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
|
|
}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return arg_count == 2;
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_week>(thd, this); }
|
|
};
|
|
|
|
class Item_func_yearweek :public Item_long_func
|
|
{
|
|
bool check_arguments() const
|
|
{
|
|
return args[0]->check_type_can_return_date(func_name()) ||
|
|
args[1]->check_type_can_return_int(func_name());
|
|
}
|
|
public:
|
|
Item_func_yearweek(THD *thd, Item *a, Item *b)
|
|
:Item_long_func(thd, a, b) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "yearweek"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_yearweek>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_year :public Item_long_func_date_field
|
|
{
|
|
public:
|
|
Item_func_year(THD *thd, Item *a): Item_long_func_date_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "year"; }
|
|
enum_monotonicity_info get_monotonicity_info() const;
|
|
longlong val_int_endpoint(bool left_endp, bool *incl_endp);
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
max_length=4*MY_CHARSET_BIN_MB_MAXLEN;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_year>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_weekday :public Item_func
|
|
{
|
|
bool odbc_type;
|
|
public:
|
|
Item_func_weekday(THD *thd, Item *a, bool type_arg):
|
|
Item_func(thd, a), odbc_type(type_arg) { collation.set_numeric(); }
|
|
longlong val_int();
|
|
double val_real() { DBUG_ASSERT(fixed == 1); return (double) val_int(); }
|
|
String *val_str(String *str)
|
|
{
|
|
DBUG_ASSERT(fixed == 1);
|
|
str->set(val_int(), &my_charset_bin);
|
|
return null_value ? 0 : str;
|
|
}
|
|
const char *func_name() const
|
|
{
|
|
return (odbc_type ? "dayofweek" : "weekday");
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
|
|
{
|
|
return type_handler()->Item_get_date_with_warn(thd, this, ltime, fuzzydate);
|
|
}
|
|
const Type_handler *type_handler() const { return &type_handler_long; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals= 0;
|
|
fix_char_length(1);
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_date_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_weekday>(thd, this); }
|
|
};
|
|
|
|
class Item_func_dayname :public Item_func_weekday
|
|
{
|
|
MY_LOCALE *locale;
|
|
public:
|
|
Item_func_dayname(THD *thd, Item *a): Item_func_weekday(thd, a, 0) {}
|
|
const char *func_name() const { return "dayname"; }
|
|
String *val_str(String *str);
|
|
const Type_handler *type_handler() const { return &type_handler_varchar; }
|
|
bool fix_length_and_dec();
|
|
bool check_partition_func_processor(void *int_arg) {return TRUE;}
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
|
|
}
|
|
};
|
|
|
|
|
|
class Item_func_seconds_hybrid: public Item_func_numhybrid
|
|
{
|
|
public:
|
|
Item_func_seconds_hybrid(THD *thd): Item_func_numhybrid(thd) {}
|
|
Item_func_seconds_hybrid(THD *thd, Item *a): Item_func_numhybrid(thd, a) {}
|
|
void fix_length_and_dec_generic(uint dec)
|
|
{
|
|
DBUG_ASSERT(dec <= TIME_SECOND_PART_DIGITS);
|
|
decimals= dec;
|
|
max_length=17 + (decimals ? decimals + 1 : 0);
|
|
maybe_null= true;
|
|
if (decimals)
|
|
set_handler(&type_handler_newdecimal);
|
|
else
|
|
set_handler(type_handler_long_or_longlong());
|
|
}
|
|
double real_op() { DBUG_ASSERT(0); return 0; }
|
|
String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
|
|
bool date_op(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
|
|
{
|
|
DBUG_ASSERT(0);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
class Item_func_unix_timestamp :public Item_func_seconds_hybrid
|
|
{
|
|
bool get_timestamp_value(my_time_t *seconds, ulong *second_part);
|
|
public:
|
|
Item_func_unix_timestamp(THD *thd): Item_func_seconds_hybrid(thd) {}
|
|
Item_func_unix_timestamp(THD *thd, Item *a):
|
|
Item_func_seconds_hybrid(thd, a) {}
|
|
const char *func_name() const { return "unix_timestamp"; }
|
|
enum_monotonicity_info get_monotonicity_info() const;
|
|
longlong val_int_endpoint(bool left_endp, bool *incl_endp);
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
/*
|
|
UNIX_TIMESTAMP() depends on the current timezone
|
|
(and thus may not be used as a partitioning function)
|
|
when its argument is NOT of the TIMESTAMP type.
|
|
*/
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_timestamp_args();
|
|
}
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
if (arg_count)
|
|
return FALSE;
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_TIME_FUNC);
|
|
}
|
|
bool fix_length_and_dec()
|
|
{
|
|
fix_length_and_dec_generic(arg_count ?
|
|
args[0]->datetime_precision(current_thd) : 0);
|
|
return FALSE;
|
|
}
|
|
longlong int_op();
|
|
my_decimal *decimal_op(my_decimal* buf);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_unix_timestamp>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_time_to_sec :public Item_func_seconds_hybrid
|
|
{
|
|
public:
|
|
Item_func_time_to_sec(THD *thd, Item *item):
|
|
Item_func_seconds_hybrid(thd, item) {}
|
|
const char *func_name() const { return "time_to_sec"; }
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_time_args();
|
|
}
|
|
bool fix_length_and_dec()
|
|
{
|
|
fix_length_and_dec_generic(args[0]->time_precision(current_thd));
|
|
return FALSE;
|
|
}
|
|
longlong int_op();
|
|
my_decimal *decimal_op(my_decimal* buf);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_time_to_sec>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_datefunc :public Item_func
|
|
{
|
|
public:
|
|
Item_datefunc(THD *thd): Item_func(thd) { }
|
|
Item_datefunc(THD *thd, Item *a): Item_func(thd, a) { }
|
|
Item_datefunc(THD *thd, Item *a, Item *b): Item_func(thd, a, b) { }
|
|
const Type_handler *type_handler() const { return &type_handler_newdate; }
|
|
longlong val_int() { return Date(this).to_longlong(); }
|
|
double val_real() { return Date(this).to_double(); }
|
|
String *val_str(String *to) { return Date(this).to_string(to); }
|
|
my_decimal *val_decimal(my_decimal *to) { return Date(this).to_decimal(to); }
|
|
bool fix_length_and_dec()
|
|
{
|
|
fix_attributes_date();
|
|
maybe_null= (arg_count > 0);
|
|
return FALSE;
|
|
}
|
|
};
|
|
|
|
|
|
class Item_timefunc :public Item_func
|
|
{
|
|
public:
|
|
Item_timefunc(THD *thd): Item_func(thd) {}
|
|
Item_timefunc(THD *thd, Item *a): Item_func(thd, a) {}
|
|
Item_timefunc(THD *thd, Item *a, Item *b): Item_func(thd, a, b) {}
|
|
Item_timefunc(THD *thd, Item *a, Item *b, Item *c): Item_func(thd, a, b ,c) {}
|
|
const Type_handler *type_handler() const { return &type_handler_time2; }
|
|
longlong val_int() { return Time(this).to_longlong(); }
|
|
double val_real() { return Time(this).to_double(); }
|
|
String *val_str(String *to) { return Time(this).to_string(to, decimals); }
|
|
my_decimal *val_decimal(my_decimal *to) { return Time(this).to_decimal(to); }
|
|
};
|
|
|
|
|
|
class Item_datetimefunc :public Item_func
|
|
{
|
|
public:
|
|
Item_datetimefunc(THD *thd): Item_func(thd) {}
|
|
Item_datetimefunc(THD *thd, Item *a): Item_func(thd, a) {}
|
|
Item_datetimefunc(THD *thd, Item *a, Item *b): Item_func(thd, a, b) {}
|
|
Item_datetimefunc(THD *thd, Item *a, Item *b, Item *c):
|
|
Item_func(thd, a, b ,c) {}
|
|
const Type_handler *type_handler() const { return &type_handler_datetime2; }
|
|
longlong val_int() { return Datetime(this).to_longlong(); }
|
|
double val_real() { return Datetime(this).to_double(); }
|
|
String *val_str(String *to) { return Datetime(this).to_string(to, decimals); }
|
|
my_decimal *val_decimal(my_decimal *to) { return Datetime(this).to_decimal(to); }
|
|
};
|
|
|
|
|
|
/* Abstract CURTIME function. Children should define what time zone is used */
|
|
|
|
class Item_func_curtime :public Item_timefunc
|
|
{
|
|
MYSQL_TIME ltime;
|
|
query_id_t last_query_id;
|
|
public:
|
|
Item_func_curtime(THD *thd, uint dec): Item_timefunc(thd), last_query_id(0)
|
|
{ decimals= dec; }
|
|
bool fix_fields(THD *, Item **);
|
|
bool fix_length_and_dec() { fix_attributes_time(decimals); return FALSE; }
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
/*
|
|
Abstract method that defines which time zone is used for conversion.
|
|
Converts time current time in my_time_t representation to broken-down
|
|
MYSQL_TIME representation using UTC-SYSTEM or per-thread time zone.
|
|
*/
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time)=0;
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_TIME_FUNC);
|
|
}
|
|
void print(String *str, enum_query_type query_type);
|
|
};
|
|
|
|
|
|
class Item_func_curtime_local :public Item_func_curtime
|
|
{
|
|
public:
|
|
Item_func_curtime_local(THD *thd, uint dec): Item_func_curtime(thd, dec) {}
|
|
const char *func_name() const { return "curtime"; }
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_curtime_local>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_curtime_utc :public Item_func_curtime
|
|
{
|
|
public:
|
|
Item_func_curtime_utc(THD *thd, uint dec): Item_func_curtime(thd, dec) {}
|
|
const char *func_name() const { return "utc_time"; }
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_curtime_utc>(thd, this); }
|
|
};
|
|
|
|
|
|
/* Abstract CURDATE function. See also Item_func_curtime. */
|
|
|
|
class Item_func_curdate :public Item_datefunc
|
|
{
|
|
query_id_t last_query_id;
|
|
MYSQL_TIME ltime;
|
|
public:
|
|
Item_func_curdate(THD *thd): Item_datefunc(thd), last_query_id(0) {}
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time)=0;
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_TIME_FUNC);
|
|
}
|
|
};
|
|
|
|
|
|
class Item_func_curdate_local :public Item_func_curdate
|
|
{
|
|
public:
|
|
Item_func_curdate_local(THD *thd): Item_func_curdate(thd) {}
|
|
const char *func_name() const { return "curdate"; }
|
|
void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_curdate_local>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_curdate_utc :public Item_func_curdate
|
|
{
|
|
public:
|
|
Item_func_curdate_utc(THD *thd): Item_func_curdate(thd) {}
|
|
const char *func_name() const { return "utc_date"; }
|
|
void store_now_in_TIME(THD* thd, MYSQL_TIME *now_time);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_curdate_utc>(thd, this); }
|
|
};
|
|
|
|
|
|
/* Abstract CURRENT_TIMESTAMP function. See also Item_func_curtime */
|
|
|
|
class Item_func_now :public Item_datetimefunc
|
|
{
|
|
MYSQL_TIME ltime;
|
|
query_id_t last_query_id;
|
|
public:
|
|
Item_func_now(THD *thd, uint dec): Item_datetimefunc(thd), last_query_id(0)
|
|
{ decimals= dec; }
|
|
bool fix_fields(THD *, Item **);
|
|
bool fix_length_and_dec()
|
|
{ fix_attributes_datetime(decimals); return FALSE;}
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time)=0;
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
/*
|
|
NOW is safe for replication as slaves will run with same time as
|
|
master
|
|
*/
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_TIME_FUNC);
|
|
}
|
|
void print(String *str, enum_query_type query_type);
|
|
};
|
|
|
|
|
|
class Item_func_now_local :public Item_func_now
|
|
{
|
|
public:
|
|
Item_func_now_local(THD *thd, uint dec): Item_func_now(thd, dec) {}
|
|
const char *func_name() const { return "current_timestamp"; }
|
|
int save_in_field(Field *field, bool no_conversions);
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time);
|
|
virtual enum Functype functype() const { return NOW_FUNC; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_now_local>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_now_utc :public Item_func_now
|
|
{
|
|
public:
|
|
Item_func_now_utc(THD *thd, uint dec): Item_func_now(thd, dec) {}
|
|
const char *func_name() const { return "utc_timestamp"; }
|
|
virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time);
|
|
virtual enum Functype functype() const { return NOW_UTC_FUNC; }
|
|
virtual bool check_vcol_func_processor(void *arg)
|
|
{
|
|
return mark_unsupported_function(func_name(), "()", arg,
|
|
VCOL_TIME_FUNC | VCOL_NON_DETERMINISTIC);
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_now_utc>(thd, this); }
|
|
};
|
|
|
|
|
|
/*
|
|
This is like NOW(), but always uses the real current time, not the
|
|
query_start(). This matches the Oracle behavior.
|
|
*/
|
|
class Item_func_sysdate_local :public Item_func_now
|
|
{
|
|
public:
|
|
Item_func_sysdate_local(THD *thd, uint dec): Item_func_now(thd, dec) {}
|
|
bool const_item() const { return 0; }
|
|
const char *func_name() const { return "sysdate"; }
|
|
void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time);
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
table_map used_tables() const { return RAND_TABLE_BIT; }
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
return mark_unsupported_function(func_name(), "()", arg,
|
|
VCOL_TIME_FUNC | VCOL_NON_DETERMINISTIC);
|
|
}
|
|
virtual enum Functype functype() const { return SYSDATE_FUNC; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_sysdate_local>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_from_days :public Item_datefunc
|
|
{
|
|
bool check_arguments() const
|
|
{ return args[0]->check_type_can_return_int(func_name()); }
|
|
public:
|
|
Item_func_from_days(THD *thd, Item *a): Item_datefunc(thd, a) {}
|
|
const char *func_name() const { return "from_days"; }
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return has_date_args() || has_time_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_from_days>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_date_format :public Item_str_func
|
|
{
|
|
bool check_arguments() const
|
|
{
|
|
return args[0]->check_type_can_return_date(func_name()) ||
|
|
check_argument_types_can_return_text(1, arg_count);
|
|
}
|
|
const MY_LOCALE *locale;
|
|
int fixed_length;
|
|
String value;
|
|
protected:
|
|
bool is_time_format;
|
|
public:
|
|
Item_func_date_format(THD *thd, Item *a, Item *b):
|
|
Item_str_func(thd, a, b), locale(0), is_time_format(false) {}
|
|
Item_func_date_format(THD *thd, Item *a, Item *b, Item *c):
|
|
Item_str_func(thd, a, b, c), locale(0), is_time_format(false) {}
|
|
String *val_str(String *str);
|
|
const char *func_name() const { return "date_format"; }
|
|
bool fix_length_and_dec();
|
|
uint format_length(const String *format);
|
|
bool eq(const Item *item, bool binary_cmp) const;
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
if (arg_count > 2)
|
|
return false;
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_date_format>(thd, this); }
|
|
};
|
|
|
|
class Item_func_time_format: public Item_func_date_format
|
|
{
|
|
public:
|
|
Item_func_time_format(THD *thd, Item *a, Item *b):
|
|
Item_func_date_format(thd, a, b) { is_time_format= true; }
|
|
const char *func_name() const { return "time_format"; }
|
|
bool check_vcol_func_processor(void *arg) { return false; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_time_format>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_from_unixtime :public Item_datetimefunc
|
|
{
|
|
bool check_arguments() const
|
|
{ return args[0]->check_type_can_return_decimal(func_name()); }
|
|
Time_zone *tz;
|
|
public:
|
|
Item_func_from_unixtime(THD *thd, Item *a): Item_datetimefunc(thd, a) {}
|
|
const char *func_name() const { return "from_unixtime"; }
|
|
bool fix_length_and_dec();
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_from_unixtime>(thd, this); }
|
|
};
|
|
|
|
|
|
/*
|
|
We need Time_zone class declaration for storing pointers in
|
|
Item_func_convert_tz.
|
|
*/
|
|
class Time_zone;
|
|
|
|
/*
|
|
This class represents CONVERT_TZ() function.
|
|
The important fact about this function that it is handled in special way.
|
|
When such function is met in expression time_zone system tables are added
|
|
to global list of tables to open, so later those already opened and locked
|
|
tables can be used during this function calculation for loading time zone
|
|
descriptions.
|
|
*/
|
|
class Item_func_convert_tz :public Item_datetimefunc
|
|
{
|
|
bool check_arguments() const
|
|
{
|
|
return args[0]->check_type_can_return_date(func_name()) ||
|
|
check_argument_types_can_return_text(1, arg_count);
|
|
}
|
|
/*
|
|
If time zone parameters are constants we are caching objects that
|
|
represent them (we use separate from_tz_cached/to_tz_cached members
|
|
to indicate this fact, since NULL is legal value for from_tz/to_tz
|
|
members.
|
|
*/
|
|
bool from_tz_cached, to_tz_cached;
|
|
Time_zone *from_tz, *to_tz;
|
|
public:
|
|
Item_func_convert_tz(THD *thd, Item *a, Item *b, Item *c):
|
|
Item_datetimefunc(thd, a, b, c), from_tz_cached(0), to_tz_cached(0) {}
|
|
const char *func_name() const { return "convert_tz"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
fix_attributes_datetime(args[0]->datetime_precision(current_thd));
|
|
maybe_null= true;
|
|
return FALSE;
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
void cleanup();
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_convert_tz>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_sec_to_time :public Item_timefunc
|
|
{
|
|
bool check_arguments() const
|
|
{ return args[0]->check_type_can_return_decimal(func_name()); }
|
|
public:
|
|
Item_func_sec_to_time(THD *thd, Item *item): Item_timefunc(thd, item) {}
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
bool fix_length_and_dec()
|
|
{
|
|
fix_attributes_time(args[0]->decimals);
|
|
maybe_null= true;
|
|
return FALSE;
|
|
}
|
|
const char *func_name() const { return "sec_to_time"; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_sec_to_time>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_date_add_interval :public Item_handled_func
|
|
{
|
|
public:
|
|
const interval_type int_type; // keep it public
|
|
const bool date_sub_interval; // keep it public
|
|
Item_date_add_interval(THD *thd, Item *a, Item *b, interval_type type_arg,
|
|
bool neg_arg):
|
|
Item_handled_func(thd, a, b), int_type(type_arg),
|
|
date_sub_interval(neg_arg) {}
|
|
const char *func_name() const { return "date_add_interval"; }
|
|
bool fix_length_and_dec();
|
|
bool eq(const Item *item, bool binary_cmp) const;
|
|
void print(String *str, enum_query_type query_type);
|
|
enum precedence precedence() const { return ADDINTERVAL_PRECEDENCE; }
|
|
bool need_parentheses_in_default() { return true; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_date_add_interval>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_extract :public Item_int_func,
|
|
public Type_handler_hybrid_field_type
|
|
{
|
|
date_mode_t m_date_mode;
|
|
const Type_handler_int_result *handler_by_length(uint32 length,
|
|
uint32 threashold)
|
|
{
|
|
if (length >= threashold)
|
|
return &type_handler_longlong;
|
|
return &type_handler_long;
|
|
}
|
|
void set_date_length(uint32 length)
|
|
{
|
|
/*
|
|
Although DATE components (e.g. YEAR, YEAR_MONTH, QUARTER, MONTH, WEEK)
|
|
cannot have a sign, we should probably still add +1,
|
|
because all around the code we assume that max_length is sign inclusive.
|
|
Another options is to set unsigned_flag to "true".
|
|
*/
|
|
set_handler(handler_by_length(max_length= length, 10)); // QQ: see above
|
|
m_date_mode= date_mode_t(0);
|
|
}
|
|
void set_day_length(uint32 length)
|
|
{
|
|
/*
|
|
Units starting with DAY can be negative:
|
|
EXTRACT(DAY FROM '-24:00:00') -> -1
|
|
*/
|
|
set_handler(handler_by_length(max_length= length + 1/*sign*/, 11));
|
|
m_date_mode= date_mode_t(0);
|
|
}
|
|
void set_time_length(uint32 length)
|
|
{
|
|
set_handler(handler_by_length(max_length= length + 1/*sign*/, 11));
|
|
m_date_mode= TIME_TIME_ONLY;
|
|
}
|
|
public:
|
|
const interval_type int_type; // keep it public
|
|
Item_extract(THD *thd, interval_type type_arg, Item *a):
|
|
Item_int_func(thd, a),
|
|
Type_handler_hybrid_field_type(&type_handler_longlong),
|
|
m_date_mode(date_mode_t(0)),
|
|
int_type(type_arg)
|
|
{ }
|
|
const Type_handler *type_handler() const
|
|
{
|
|
return Type_handler_hybrid_field_type::type_handler();
|
|
}
|
|
longlong val_int();
|
|
enum Functype functype() const { return EXTRACT_FUNC; }
|
|
const char *func_name() const { return "extract"; }
|
|
bool fix_length_and_dec();
|
|
bool eq(const Item *item, bool binary_cmp) const;
|
|
void print(String *str, enum_query_type query_type);
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg)
|
|
{
|
|
if (int_type != INTERVAL_WEEK)
|
|
return FALSE;
|
|
return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
|
|
}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
switch (int_type) {
|
|
case INTERVAL_YEAR:
|
|
case INTERVAL_YEAR_MONTH:
|
|
case INTERVAL_QUARTER:
|
|
case INTERVAL_MONTH:
|
|
/* case INTERVAL_WEEK: Not allowed as partitioning function, bug#57071 */
|
|
case INTERVAL_DAY:
|
|
return !has_date_args();
|
|
case INTERVAL_DAY_HOUR:
|
|
case INTERVAL_DAY_MINUTE:
|
|
case INTERVAL_DAY_SECOND:
|
|
case INTERVAL_DAY_MICROSECOND:
|
|
return !has_datetime_args();
|
|
case INTERVAL_HOUR:
|
|
case INTERVAL_HOUR_MINUTE:
|
|
case INTERVAL_HOUR_SECOND:
|
|
case INTERVAL_MINUTE:
|
|
case INTERVAL_MINUTE_SECOND:
|
|
case INTERVAL_SECOND:
|
|
case INTERVAL_MICROSECOND:
|
|
case INTERVAL_HOUR_MICROSECOND:
|
|
case INTERVAL_MINUTE_MICROSECOND:
|
|
case INTERVAL_SECOND_MICROSECOND:
|
|
return !has_time_args();
|
|
default:
|
|
/*
|
|
INTERVAL_LAST is only an end marker,
|
|
INTERVAL_WEEK depends on default_week_format which is a session
|
|
variable and cannot be used for partitioning. See bug#57071.
|
|
*/
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_extract>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_char_typecast :public Item_str_func
|
|
{
|
|
uint cast_length;
|
|
CHARSET_INFO *cast_cs, *from_cs;
|
|
bool charset_conversion;
|
|
String tmp_value;
|
|
bool m_suppress_warning_to_error_escalation;
|
|
bool has_explicit_length() const { return cast_length != ~0U; }
|
|
String *reuse(String *src, size_t length);
|
|
String *copy(String *src, CHARSET_INFO *cs);
|
|
uint adjusted_length_with_warn(uint length);
|
|
void check_truncation_with_warn(String *src, size_t dstlen);
|
|
void fix_length_and_dec_internal(CHARSET_INFO *fromcs);
|
|
public:
|
|
Item_char_typecast(THD *thd, Item *a, uint length_arg, CHARSET_INFO *cs_arg):
|
|
Item_str_func(thd, a), cast_length(length_arg), cast_cs(cs_arg),
|
|
m_suppress_warning_to_error_escalation(false) {}
|
|
enum Functype functype() const { return CHAR_TYPECAST_FUNC; }
|
|
bool eq(const Item *item, bool binary_cmp) const;
|
|
const char *func_name() const { return "cast_as_char"; }
|
|
CHARSET_INFO *cast_charset() const { return cast_cs; }
|
|
String *val_str(String *a);
|
|
void fix_length_and_dec_generic();
|
|
void fix_length_and_dec_numeric();
|
|
void fix_length_and_dec_str()
|
|
{
|
|
fix_length_and_dec_generic();
|
|
m_suppress_warning_to_error_escalation= true;
|
|
}
|
|
bool fix_length_and_dec()
|
|
{
|
|
return args[0]->type_handler()->Item_char_typecast_fix_length_and_dec(this);
|
|
}
|
|
void print(String *str, enum_query_type query_type);
|
|
bool need_parentheses_in_default() { return true; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_char_typecast>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_date_typecast :public Item_datefunc
|
|
{
|
|
public:
|
|
Item_date_typecast(THD *thd, Item *a): Item_datefunc(thd, a) {}
|
|
const char *func_name() const { return "cast_as_date"; }
|
|
void print(String *str, enum_query_type query_type)
|
|
{
|
|
print_cast_temporal(str, query_type);
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
|
|
bool fix_length_and_dec()
|
|
{
|
|
return args[0]->type_handler()->Item_date_typecast_fix_length_and_dec(this);
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_date_typecast>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_time_typecast :public Item_timefunc
|
|
{
|
|
public:
|
|
Item_time_typecast(THD *thd, Item *a, uint dec_arg):
|
|
Item_timefunc(thd, a) { decimals= dec_arg; }
|
|
const char *func_name() const { return "cast_as_time"; }
|
|
void print(String *str, enum_query_type query_type)
|
|
{
|
|
print_cast_temporal(str, query_type);
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
|
|
bool fix_length_and_dec()
|
|
{
|
|
return args[0]->type_handler()->
|
|
Item_time_typecast_fix_length_and_dec(this);
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_time_typecast>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_datetime_typecast :public Item_datetimefunc
|
|
{
|
|
public:
|
|
Item_datetime_typecast(THD *thd, Item *a, uint dec_arg):
|
|
Item_datetimefunc(thd, a) { decimals= dec_arg; }
|
|
const char *func_name() const { return "cast_as_datetime"; }
|
|
void print(String *str, enum_query_type query_type)
|
|
{
|
|
print_cast_temporal(str, query_type);
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
|
|
bool fix_length_and_dec()
|
|
{
|
|
return args[0]->type_handler()->
|
|
Item_datetime_typecast_fix_length_and_dec(this);
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_datetime_typecast>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_makedate :public Item_datefunc
|
|
{
|
|
bool check_arguments() const
|
|
{ return check_argument_types_can_return_int(0, arg_count); }
|
|
public:
|
|
Item_func_makedate(THD *thd, Item *a, Item *b):
|
|
Item_datefunc(thd, a, b) {}
|
|
const char *func_name() const { return "makedate"; }
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_makedate>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_timestamp :public Item_datetimefunc
|
|
{
|
|
bool check_arguments() const
|
|
{
|
|
return args[0]->check_type_can_return_date(func_name()) ||
|
|
args[1]->check_type_can_return_time(func_name());
|
|
}
|
|
public:
|
|
Item_func_timestamp(THD *thd, Item *a, Item *b)
|
|
:Item_datetimefunc(thd, a, b)
|
|
{ }
|
|
const char *func_name() const { return "timestamp"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
THD *thd= current_thd;
|
|
uint dec0= args[0]->datetime_precision(thd);
|
|
uint dec1= Interval_DDhhmmssff::fsp(thd, args[1]);
|
|
fix_attributes_datetime(MY_MAX(dec0, dec1));
|
|
maybe_null= true;
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
|
|
{
|
|
Datetime dt(thd, args[0], date_mode_t(0));
|
|
if (!dt.is_valid_datetime())
|
|
return null_value= true;
|
|
Interval_DDhhmmssff it(thd, args[1]);
|
|
if (!it.is_valid_interval_DDhhmmssff())
|
|
return null_value= true;
|
|
return (null_value= Sec6_add(dt.get_mysql_time(), it.get_mysql_time(), 1).
|
|
to_datetime(ltime));
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_timestamp>(thd, this); }
|
|
};
|
|
|
|
|
|
/**
|
|
ADDTIME(t,a) and SUBTIME(t,a) are time functions that calculate a
|
|
time/datetime value
|
|
|
|
t: time_or_datetime_expression
|
|
a: time_expression
|
|
|
|
Result: Time value or datetime value
|
|
*/
|
|
|
|
class Item_func_add_time :public Item_handled_func
|
|
{
|
|
int sign;
|
|
public:
|
|
Item_func_add_time(THD *thd, Item *a, Item *b, bool neg_arg)
|
|
:Item_handled_func(thd, a, b), sign(neg_arg ? -1 : 1)
|
|
{ }
|
|
bool fix_length_and_dec();
|
|
const char *func_name() const { return sign > 0 ? "addtime" : "subtime"; }
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_add_time>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_timediff :public Item_timefunc
|
|
{
|
|
bool check_arguments() const
|
|
{ return check_argument_types_can_return_time(0, arg_count); }
|
|
public:
|
|
Item_func_timediff(THD *thd, Item *a, Item *b): Item_timefunc(thd, a, b) {}
|
|
const char *func_name() const { return "timediff"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
THD *thd= current_thd;
|
|
uint dec= MY_MAX(args[0]->time_precision(thd),
|
|
args[1]->time_precision(thd));
|
|
fix_attributes_time(dec);
|
|
maybe_null= true;
|
|
return FALSE;
|
|
}
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_timediff>(thd, this); }
|
|
};
|
|
|
|
class Item_func_maketime :public Item_timefunc
|
|
{
|
|
bool check_arguments() const
|
|
{
|
|
return check_argument_types_can_return_int(0, 2) ||
|
|
args[2]->check_type_can_return_decimal(func_name());
|
|
}
|
|
public:
|
|
Item_func_maketime(THD *thd, Item *a, Item *b, Item *c):
|
|
Item_timefunc(thd, a, b, c)
|
|
{}
|
|
bool fix_length_and_dec()
|
|
{
|
|
fix_attributes_time(args[2]->decimals);
|
|
maybe_null= true;
|
|
return FALSE;
|
|
}
|
|
const char *func_name() const { return "maketime"; }
|
|
bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_maketime>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_microsecond :public Item_long_func_time_field
|
|
{
|
|
public:
|
|
Item_func_microsecond(THD *thd, Item *a): Item_long_func_time_field(thd, a) {}
|
|
longlong val_int();
|
|
const char *func_name() const { return "microsecond"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
maybe_null=1;
|
|
fix_char_length(6);
|
|
return FALSE;
|
|
}
|
|
bool check_partition_func_processor(void *int_arg) {return FALSE;}
|
|
bool check_vcol_func_processor(void *arg) { return FALSE;}
|
|
bool check_valid_arguments_processor(void *int_arg)
|
|
{
|
|
return !has_time_args();
|
|
}
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_microsecond>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_timestamp_diff :public Item_longlong_func
|
|
{
|
|
bool check_arguments() const
|
|
{ return check_argument_types_can_return_date(0, arg_count); }
|
|
const interval_type int_type;
|
|
public:
|
|
Item_func_timestamp_diff(THD *thd, Item *a, Item *b, interval_type type_arg):
|
|
Item_longlong_func(thd, a, b), int_type(type_arg) {}
|
|
const char *func_name() const { return "timestampdiff"; }
|
|
longlong val_int();
|
|
bool fix_length_and_dec()
|
|
{
|
|
decimals=0;
|
|
maybe_null=1;
|
|
return FALSE;
|
|
}
|
|
virtual void print(String *str, enum_query_type query_type);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_timestamp_diff>(thd, this); }
|
|
};
|
|
|
|
|
|
enum date_time_format
|
|
{
|
|
USA_FORMAT, JIS_FORMAT, ISO_FORMAT, EUR_FORMAT, INTERNAL_FORMAT
|
|
};
|
|
|
|
class Item_func_get_format :public Item_str_ascii_func
|
|
{
|
|
public:
|
|
const timestamp_type type; // keep it public
|
|
Item_func_get_format(THD *thd, timestamp_type type_arg, Item *a):
|
|
Item_str_ascii_func(thd, a), type(type_arg)
|
|
{}
|
|
String *val_str_ascii(String *str);
|
|
const char *func_name() const { return "get_format"; }
|
|
bool fix_length_and_dec()
|
|
{
|
|
maybe_null= 1;
|
|
decimals=0;
|
|
fix_length_and_charset(17, default_charset());
|
|
return FALSE;
|
|
}
|
|
virtual void print(String *str, enum_query_type query_type);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_get_format>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_str_to_date :public Item_handled_func
|
|
{
|
|
bool const_item;
|
|
String subject_converter;
|
|
String format_converter;
|
|
CHARSET_INFO *internal_charset;
|
|
public:
|
|
Item_func_str_to_date(THD *thd, Item *a, Item *b):
|
|
Item_handled_func(thd, a, b), const_item(false),
|
|
internal_charset(NULL)
|
|
{}
|
|
bool get_date_common(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate,
|
|
timestamp_type);
|
|
const char *func_name() const { return "str_to_date"; }
|
|
bool fix_length_and_dec();
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_str_to_date>(thd, this); }
|
|
};
|
|
|
|
|
|
class Item_func_last_day :public Item_datefunc
|
|
{
|
|
bool check_arguments() const
|
|
{ return args[0]->check_type_can_return_date(func_name()); }
|
|
public:
|
|
Item_func_last_day(THD *thd, Item *a): Item_datefunc(thd, a) {}
|
|
const char *func_name() const { return "last_day"; }
|
|
bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
|
|
Item *get_copy(THD *thd)
|
|
{ return get_item_copy<Item_func_last_day>(thd, this); }
|
|
};
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
class Func_handler_date_add_interval
|
|
{
|
|
protected:
|
|
static uint interval_dec(const Item *item, interval_type int_type)
|
|
{
|
|
if (int_type == INTERVAL_MICROSECOND ||
|
|
(int_type >= INTERVAL_DAY_MICROSECOND &&
|
|
int_type <= INTERVAL_SECOND_MICROSECOND))
|
|
return TIME_SECOND_PART_DIGITS;
|
|
if (int_type == INTERVAL_SECOND && item->decimals > 0)
|
|
return MY_MIN(item->decimals, TIME_SECOND_PART_DIGITS);
|
|
return 0;
|
|
}
|
|
interval_type int_type(const Item_handled_func *item) const
|
|
{
|
|
return static_cast<const Item_date_add_interval*>(item)->int_type;
|
|
}
|
|
bool sub(const Item_handled_func *item) const
|
|
{
|
|
return static_cast<const Item_date_add_interval*>(item)->date_sub_interval;
|
|
}
|
|
bool add(THD *thd, Item *item, interval_type type, bool sub, MYSQL_TIME *to) const
|
|
{
|
|
INTERVAL interval;
|
|
if (get_interval_value(thd, item, type, &interval))
|
|
return true;
|
|
if (sub)
|
|
interval.neg = !interval.neg;
|
|
return date_add_interval(thd, to, type, interval);
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_date_add_interval_datetime:
|
|
public Item_handled_func::Handler_datetime,
|
|
public Func_handler_date_add_interval
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
uint dec= MY_MAX(item->arguments()[0]->datetime_precision(current_thd),
|
|
interval_dec(item->arguments()[1], int_type(item)));
|
|
item->fix_attributes_datetime(dec);
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
Datetime dt(thd, item->arguments()[0], date_mode_t(0));
|
|
if (!dt.is_valid_datetime() ||
|
|
dt.check_date_with_warn(thd, TIME_NO_ZERO_DATE | TIME_NO_ZERO_IN_DATE))
|
|
return (item->null_value= true);
|
|
dt.copy_to_mysql_time(to);
|
|
return (item->null_value= add(thd, item->arguments()[1],
|
|
int_type(item), sub(item), to));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_date_add_interval_datetime_arg0_time:
|
|
public Func_handler_date_add_interval_datetime
|
|
{
|
|
public:
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const;
|
|
};
|
|
|
|
|
|
class Func_handler_date_add_interval_date:
|
|
public Item_handled_func::Handler_date,
|
|
public Func_handler_date_add_interval
|
|
{
|
|
public:
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
Date d(thd, item->arguments()[0], date_mode_t(0));
|
|
if (!d.is_valid_date() ||
|
|
d.check_date_with_warn(thd, TIME_NO_ZERO_DATE | TIME_NO_ZERO_IN_DATE))
|
|
return (item->null_value= true);
|
|
d.copy_to_mysql_time(to);
|
|
return (item->null_value= add(thd, item->arguments()[1],
|
|
int_type(item), sub(item), to));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_date_add_interval_time:
|
|
public Item_handled_func::Handler_time,
|
|
public Func_handler_date_add_interval
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
uint dec= MY_MAX(item->arguments()[0]->time_precision(current_thd),
|
|
interval_dec(item->arguments()[1], int_type(item)));
|
|
item->fix_attributes_time(dec);
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
Time t(thd, item->arguments()[0]);
|
|
if (!t.is_valid_time())
|
|
return (item->null_value= true);
|
|
t.copy_to_mysql_time(to);
|
|
return (item->null_value= add(thd, item->arguments()[1],
|
|
int_type(item), sub(item), to));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_date_add_interval_string:
|
|
public Item_handled_func::Handler_temporal_string,
|
|
public Func_handler_date_add_interval
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
uint dec= MY_MAX(item->arguments()[0]->datetime_precision(current_thd),
|
|
interval_dec(item->arguments()[1], int_type(item)));
|
|
item->collation.set(item->default_charset(),
|
|
DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
|
|
item->fix_char_length_temporal_not_fixed_dec(MAX_DATETIME_WIDTH, dec);
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
if (item->arguments()[0]->get_date(thd, to, date_mode_t(0)) ||
|
|
(to->time_type != MYSQL_TIMESTAMP_TIME &&
|
|
check_date_with_warn(thd, to, TIME_NO_ZERO_DATE | TIME_NO_ZERO_IN_DATE,
|
|
MYSQL_TIMESTAMP_ERROR)))
|
|
return (item->null_value= true);
|
|
return (item->null_value= add(thd, item->arguments()[1],
|
|
int_type(item), sub(item), to));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_sign
|
|
{
|
|
protected:
|
|
int m_sign;
|
|
Func_handler_sign(int sign) :m_sign(sign) { }
|
|
};
|
|
|
|
|
|
class Func_handler_add_time_datetime:
|
|
public Item_handled_func::Handler_datetime,
|
|
public Func_handler_sign
|
|
{
|
|
public:
|
|
Func_handler_add_time_datetime(int sign)
|
|
:Func_handler_sign(sign)
|
|
{ }
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
THD *thd= current_thd;
|
|
uint dec0= item->arguments()[0]->datetime_precision(thd);
|
|
uint dec1= Interval_DDhhmmssff::fsp(thd, item->arguments()[1]);
|
|
item->fix_attributes_datetime(MY_MAX(dec0, dec1));
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
DBUG_ASSERT(item->is_fixed());
|
|
Datetime dt(thd, item->arguments()[0], date_mode_t(0));
|
|
if (!dt.is_valid_datetime())
|
|
return item->null_value= true;
|
|
Interval_DDhhmmssff it(thd, item->arguments()[1]);
|
|
if (!it.is_valid_interval_DDhhmmssff())
|
|
return item->null_value= true;
|
|
return (item->null_value= (Sec6_add(dt.get_mysql_time(),
|
|
it.get_mysql_time(), m_sign).
|
|
to_datetime(to)));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_add_time_time:
|
|
public Item_handled_func::Handler_time,
|
|
public Func_handler_sign
|
|
{
|
|
public:
|
|
Func_handler_add_time_time(int sign)
|
|
:Func_handler_sign(sign)
|
|
{ }
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
THD *thd= current_thd;
|
|
uint dec0= item->arguments()[0]->time_precision(thd);
|
|
uint dec1= Interval_DDhhmmssff::fsp(thd, item->arguments()[1]);
|
|
item->fix_attributes_time(MY_MAX(dec0, dec1));
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
DBUG_ASSERT(item->is_fixed());
|
|
Time t(thd, item->arguments()[0]);
|
|
if (!t.is_valid_time())
|
|
return item->null_value= true;
|
|
Interval_DDhhmmssff i(thd, item->arguments()[1]);
|
|
if (!i.is_valid_interval_DDhhmmssff())
|
|
return item->null_value= true;
|
|
return (item->null_value= (Sec6_add(t.get_mysql_time(),
|
|
i.get_mysql_time(), m_sign).
|
|
to_time(thd, to, item->decimals)));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_add_time_string:
|
|
public Item_handled_func::Handler_temporal_string,
|
|
public Func_handler_sign
|
|
{
|
|
public:
|
|
Func_handler_add_time_string(int sign)
|
|
:Func_handler_sign(sign)
|
|
{ }
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
uint dec0= item->arguments()[0]->decimals;
|
|
uint dec1= Interval_DDhhmmssff::fsp(current_thd, item->arguments()[1]);
|
|
uint dec= MY_MAX(dec0, dec1);
|
|
item->collation.set(item->default_charset(),
|
|
DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
|
|
item->fix_char_length_temporal_not_fixed_dec(MAX_DATETIME_WIDTH, dec);
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
DBUG_ASSERT(item->is_fixed());
|
|
// Detect a proper timestamp type based on the argument values
|
|
Temporal_hybrid l_time1(thd, item->arguments()[0], TIME_TIME_ONLY);
|
|
if (!l_time1.is_valid_temporal())
|
|
return (item->null_value= true);
|
|
Interval_DDhhmmssff l_time2(thd, item->arguments()[1]);
|
|
if (!l_time2.is_valid_interval_DDhhmmssff())
|
|
return (item->null_value= true);
|
|
Sec6_add add(l_time1.get_mysql_time(), l_time2.get_mysql_time(), m_sign);
|
|
return (item->null_value= (l_time1.get_mysql_time()->time_type ==
|
|
MYSQL_TIMESTAMP_TIME ?
|
|
add.to_time(thd, to, item->decimals) :
|
|
add.to_datetime(to)));
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_str_to_date_datetime_sec:
|
|
public Item_handled_func::Handler_datetime
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
item->fix_attributes_datetime(0);
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
return static_cast<Item_func_str_to_date*>(item)->
|
|
get_date_common(thd, to, fuzzy, MYSQL_TIMESTAMP_DATETIME);
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_str_to_date_datetime_usec:
|
|
public Item_handled_func::Handler_datetime
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
item->fix_attributes_datetime(TIME_SECOND_PART_DIGITS);
|
|
return false;
|
|
}
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
return static_cast<Item_func_str_to_date*>(item)->
|
|
get_date_common(thd, to, fuzzy, MYSQL_TIMESTAMP_DATETIME);
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_str_to_date_date: public Item_handled_func::Handler_date
|
|
{
|
|
public:
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
return static_cast<Item_func_str_to_date*>(item)->
|
|
get_date_common(thd, to, fuzzy, MYSQL_TIMESTAMP_DATE);
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_str_to_date_time: public Item_handled_func::Handler_time
|
|
{
|
|
public:
|
|
bool get_date(THD *thd, Item_handled_func *item,
|
|
MYSQL_TIME *to, date_mode_t fuzzy) const
|
|
{
|
|
if (static_cast<Item_func_str_to_date*>(item)->
|
|
get_date_common(thd, to, fuzzy, MYSQL_TIMESTAMP_TIME))
|
|
return true;
|
|
if (to->day)
|
|
{
|
|
/*
|
|
Day part for time type can be nonzero value and so
|
|
we should add hours from day part to hour part to
|
|
keep valid time value.
|
|
*/
|
|
to->hour+= to->day * 24;
|
|
to->day= 0;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_str_to_date_time_sec: public Func_handler_str_to_date_time
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
item->fix_attributes_time(0);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
class Func_handler_str_to_date_time_usec: public Func_handler_str_to_date_time
|
|
{
|
|
public:
|
|
bool fix_length_and_dec(Item_handled_func *item) const
|
|
{
|
|
item->fix_attributes_time(TIME_SECOND_PART_DIGITS);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
#endif /* ITEM_TIMEFUNC_INCLUDED */
|