FM / private

/usr/include/mysql/server/private

Name	Size	Mode	Actions
atomic/	-	0755	rm
data/	-	0755	rm
providers/	-	0755	rm
aligned.h	1136	0644	edit dl rm
aria_backup.h	1787	0644	edit dl rm
assume_aligned.h	2350	0644	edit dl rm
authors.h	10194	0644	edit dl rm
backup.h	1703	0644	edit dl rm
bounded_queue.h	6093	0644	edit dl rm
client_settings.h	1935	0644	edit dl rm
compat56.h	2280	0644	edit dl rm
config.h	14351	0644	edit dl rm
contributors.h	4931	0644	edit dl rm
create_options.h	4193	0644	edit dl rm
create_tmp_table.h	2808	0644	edit dl rm
cset_narrowing.h	3968	0644	edit dl rm
custom_conf.h	1082	0644	edit dl rm
datadict.h	1700	0644	edit dl rm
ddl_log.h	12807	0644	edit dl rm
debug.h	1234	0644	edit dl rm
debug_sync.h	2046	0644	edit dl rm
derived_handler.h	2379	0644	edit dl rm
derror.h	980	0644	edit dl rm
des_key_file.h	1236	0644	edit dl rm
discover.h	1570	0644	edit dl rm
dur_prop.h	1082	0644	edit dl rm
embedded_priv.h	1733	0644	edit dl rm
events.h	4704	0644	edit dl rm
event_data_objects.h	4187	0644	edit dl rm
event_db_repository.h	3648	0644	edit dl rm
event_parse_data.h	2899	0644	edit dl rm
event_queue.h	3438	0644	edit dl rm
event_scheduler.h	3290	0644	edit dl rm
field.h	222414	0644	edit dl rm
field_comp.h	1174	0644	edit dl rm
filesort.h	7283	0644	edit dl rm
filesort_utils.h	8195	0644	edit dl rm
ft_global.h	3113	0644	edit dl rm
gcalc_slicescan.h	17330	0644	edit dl rm
gcalc_tools.h	11900	0644	edit dl rm
grant.h	2758	0644	edit dl rm
group_by_handler.h	3534	0644	edit dl rm
gstream.h	2437	0644	edit dl rm
handler.h	199857	0644	edit dl rm
handle_connections_win.h	884	0644	edit dl rm
hash.h	4452	0644	edit dl rm
hash_filo.h	5599	0644	edit dl rm
ha_handler_stats.h	2335	0644	edit dl rm
ha_partition.h	64696	0644	edit dl rm
ha_sequence.h	6245	0644	edit dl rm
heap.h	9487	0644	edit dl rm
hostname.h	5419	0644	edit dl rm
ilist.h	7237	0644	edit dl rm
init.h	852	0644	edit dl rm
innodb_priv.h	1319	0644	edit dl rm
item.h	285458	0644	edit dl rm
item_cmpfunc.h	135218	0644	edit dl rm
item_create.h	11508	0644	edit dl rm
item_func.h	138683	0644	edit dl rm
item_geofunc.h	39612	0644	edit dl rm
item_jsonfunc.h	25429	0644	edit dl rm
item_row.h	5229	0644	edit dl rm
item_strfunc.h	75265	0644	edit dl rm
item_subselect.h	59087	0644	edit dl rm
item_sum.h	72695	0644	edit dl rm
item_timefunc.h	65896	0644	edit dl rm
item_vers.h	4413	0644	edit dl rm
item_windowfunc.h	35089	0644	edit dl rm
item_xmlfunc.h	4650	0644	edit dl rm
json_table.h	9667	0644	edit dl rm
key.h	2132	0644	edit dl rm
keycaches.h	1995	0644	edit dl rm
lex.h	29840	0644	edit dl rm
lex_charset.h	24313	0644	edit dl rm
lex_hash.h	143108	0644	edit dl rm
lex_ident.h	2122	0644	edit dl rm
lex_string.h	4077	0644	edit dl rm
lex_symbol.h	1323	0644	edit dl rm
lex_token.h	42641	0644	edit dl rm
lf.h	6462	0644	edit dl rm
lock.h	2220	0644	edit dl rm
log.h	46462	0644	edit dl rm
log_event.h	189467	0644	edit dl rm
log_event_data_type.h	1890	0644	edit dl rm
log_event_old.h	19830	0644	edit dl rm
log_slow.h	2442	0644	edit dl rm
maria.h	5872	0644	edit dl rm
mariadb.h	1277	0644	edit dl rm
mdl.h	38893	0644	edit dl rm
mem_root_array.h	7106	0644	edit dl rm
message.h	1195	0644	edit dl rm
multi_range_read.h	23179	0644	edit dl rm
myisam.h	17506	0644	edit dl rm
myisamchk.h	4734	0644	edit dl rm
myisammrg.h	4897	0644	edit dl rm
myisampack.h	14929	0644	edit dl rm
mysqld.h	41225	0644	edit dl rm
mysqld_default_groups.h	204	0644	edit dl rm
mysqld_suffix.h	1201	0644	edit dl rm
mysys_err.h	3022	0644	edit dl rm
my_alarm.h	2429	0644	edit dl rm
my_apc.h	4747	0644	edit dl rm
my_atomic.h	7281	0644	edit dl rm
my_atomic_wrapper.h	3051	0644	edit dl rm
my_base.h	27750	0644	edit dl rm
my_bit.h	6196	0644	edit dl rm
my_bitmap.h	5502	0644	edit dl rm
my_check_opt.h	2618	0644	edit dl rm
my_compare.h	11194	0644	edit dl rm
my_counter.h	1721	0644	edit dl rm
my_cpu.h	4885	0644	edit dl rm
my_crypt.h	904	0644	edit dl rm
my_decimal.h	14504	0644	edit dl rm
my_default.h	1880	0644	edit dl rm
my_handler_errors.h	4882	0644	edit dl rm
my_json_writer.h	18706	0644	edit dl rm
my_libwrap.h	1183	0644	edit dl rm
my_md5.h	1486	0644	edit dl rm
my_minidump.h	848	0644	edit dl rm
my_nosys.h	1438	0644	edit dl rm
my_rdtsc.h	10119	0644	edit dl rm
my_rnd.h	1014	0644	edit dl rm
my_service_manager.h	2087	0644	edit dl rm
my_stacktrace.h	3215	0644	edit dl rm
my_stack_alloc.h	6493	0644	edit dl rm
my_time.h	10414	0644	edit dl rm
my_tree.h	3991	0644	edit dl rm
my_uctype.h	69528	0644	edit dl rm
my_user.h	1126	0644	edit dl rm
my_virtual_mem.h	1255	0644	edit dl rm
opt_histogram_json.h	4638	0644	edit dl rm
opt_range.h	65903	0644	edit dl rm
opt_subselect.h	14545	0644	edit dl rm
opt_trace.h	9505	0644	edit dl rm
opt_trace_context.h	3291	0644	edit dl rm
parse_file.h	4424	0644	edit dl rm
partition_element.h	5428	0644	edit dl rm
partition_info.h	19864	0644	edit dl rm
password.h	1621	0644	edit dl rm
pfs_file_provider.h	3153	0644	edit dl rm
pfs_idle_provider.h	1385	0644	edit dl rm
pfs_memory_provider.h	1626	0644	edit dl rm
pfs_metadata_provider.h	1898	0644	edit dl rm
pfs_socket_provider.h	2258	0644	edit dl rm
pfs_stage_provider.h	1556	0644	edit dl rm
pfs_statement_provider.h	4347	0644	edit dl rm
pfs_table_provider.h	2625	0644	edit dl rm
pfs_thread_provider.h	5560	0644	edit dl rm
pfs_transaction_provider.h	2846	0644	edit dl rm
privilege.h	28853	0644	edit dl rm
probes_mysql.h	973	0644	edit dl rm
probes_mysql_nodtrace.h	6087	0644	edit dl rm
procedure.h	6819	0644	edit dl rm
protocol.h	12537	0644	edit dl rm
proxy_protocol.h	548	0644	edit dl rm
queues.h	3477	0644	edit dl rm
records.h	3147	0644	edit dl rm
replication.h	16130	0644	edit dl rm
repl_failsafe.h	1585	0644	edit dl rm
rijndael.h	1711	0644	edit dl rm
rowid_filter.h	15474	0644	edit dl rm
rpl_constants.h	3357	0644	edit dl rm
rpl_filter.h	4774	0644	edit dl rm
rpl_gtid.h	29985	0644	edit dl rm
rpl_injector.h	9621	0644	edit dl rm
rpl_mi.h	16636	0644	edit dl rm
rpl_parallel.h	18228	0644	edit dl rm
rpl_record.h	1585	0644	edit dl rm
rpl_record_old.h	1407	0644	edit dl rm
rpl_reporting.h	3713	0644	edit dl rm
rpl_rli.h	36070	0644	edit dl rm
rpl_tblmap.h	3177	0644	edit dl rm
rpl_utility.h	9800	0644	edit dl rm
scheduler.h	3199	0644	edit dl rm
scope.h	4393	0644	edit dl rm
select_handler.h	2228	0644	edit dl rm
semisync.h	2287	0644	edit dl rm
semisync_master.h	25764	0644	edit dl rm
semisync_master_ack_receiver.h	8709	0644	edit dl rm
semisync_slave.h	3736	0644	edit dl rm
service_versions.h	2285	0644	edit dl rm
session_tracker.h	14275	0644	edit dl rm
set_var.h	17331	0644	edit dl rm
slave.h	12392	0644	edit dl rm
socketpair.h	842	0644	edit dl rm
source_revision.h	67	0644	edit dl rm
sp.h	22588	0644	edit dl rm
span.h	3931	0644	edit dl rm
spatial.h	22698	0644	edit dl rm
sp_cache.h	2037	0644	edit dl rm
sp_head.h	64917	0644	edit dl rm
sp_pcontext.h	25427	0644	edit dl rm
sp_rcontext.h	14441	0644	edit dl rm
sql_acl.h	14167	0644	edit dl rm
sql_admin.h	2915	0644	edit dl rm
sql_alloc.h	1732	0644	edit dl rm
sql_alter.h	15395	0644	edit dl rm
sql_analyse.h	11052	0644	edit dl rm
sql_analyze_stmt.h	12683	0644	edit dl rm
sql_array.h	6858	0644	edit dl rm
sql_audit.h	14162	0644	edit dl rm
sql_base.h	26050	0644	edit dl rm
sql_basic_types.h	9523	0644	edit dl rm
sql_binlog.h	895	0644	edit dl rm
sql_bitmap.h	7842	0644	edit dl rm
sql_bootstrap.h	1812	0644	edit dl rm
sql_cache.h	21676	0644	edit dl rm
sql_callback.h	1542	0644	edit dl rm
sql_class.h	271836	0644	edit dl rm
sql_cmd.h	5962	0644	edit dl rm
sql_command.h	4800	0644	edit dl rm
sql_connect.h	4087	0644	edit dl rm
sql_const.h	11630	0644	edit dl rm
sql_crypt.h	1437	0644	edit dl rm
sql_cte.h	16494	0644	edit dl rm
sql_cursor.h	4428	0644	edit dl rm
sql_db.h	2438	0644	edit dl rm
sql_debug.h	5727	0644	edit dl rm
sql_delete.h	1343	0644	edit dl rm
sql_derived.h	1289	0644	edit dl rm
sql_digest.h	3819	0644	edit dl rm
sql_digest_stream.h	1567	0644	edit dl rm
sql_do.h	954	0644	edit dl rm
sql_error.h	39843	0644	edit dl rm
sql_explain.h	30319	0644	edit dl rm
sql_expression_cache.h	4359	0644	edit dl rm
sql_get_diagnostics.h	7883	0644	edit dl rm
sql_handler.h	2910	0644	edit dl rm
sql_help.h	995	0644	edit dl rm
sql_hset.h	3401	0644	edit dl rm
sql_insert.h	5173	0644	edit dl rm
sql_i_s.h	8487	0644	edit dl rm
sql_join_cache.h	48659	0644	edit dl rm
sql_lex.h	174931	0644	edit dl rm
sql_lifo_buffer.h	9685	0644	edit dl rm
sql_limit.h	3187	0644	edit dl rm
sql_list.h	22391	0644	edit dl rm
sql_load.h	1276	0644	edit dl rm
sql_locale.h	2701	0644	edit dl rm
sql_manager.h	960	0644	edit dl rm
sql_mode.h	6735	0644	edit dl rm
sql_parse.h	8970	0644	edit dl rm
sql_partition.h	12674	0644	edit dl rm
sql_partition_admin.h	5940	0644	edit dl rm
sql_plist.h	7711	0644	edit dl rm
sql_plugin.h	7577	0644	edit dl rm
sql_plugin_compat.h	2237	0644	edit dl rm
sql_prepare.h	11409	0644	edit dl rm
sql_priv.h	18528	0644	edit dl rm
sql_profile.h	7816	0644	edit dl rm
sql_reload.h	1036	0644	edit dl rm
sql_rename.h	982	0644	edit dl rm
sql_repl.h	3045	0644	edit dl rm
sql_schema.h	3303	0644	edit dl rm
sql_select.h	89743	0644	edit dl rm
sql_sequence.h	5177	0644	edit dl rm
sql_servers.h	1777	0644	edit dl rm
sql_show.h	9819	0644	edit dl rm
sql_signal.h	3362	0644	edit dl rm
sql_sort.h	21964	0644	edit dl rm
sql_statistics.h	16504	0644	edit dl rm
sql_string.h	39009	0644	edit dl rm
sql_table.h	9812	0644	edit dl rm
sql_test.h	2665	0644	edit dl rm
sql_time.h	8505	0644	edit dl rm
sql_trigger.h	12332	0644	edit dl rm
sql_truncate.h	2079	0644	edit dl rm
sql_tvc.h	2418	0644	edit dl rm
sql_type.h	297272	0644	edit dl rm
sql_type_fixedbin.h	65578	0644	edit dl rm
sql_type_fixedbin_storage.h	5467	0644	edit dl rm
sql_type_geom.h	19039	0644	edit dl rm
sql_type_int.h	10001	0644	edit dl rm
sql_type_json.h	6155	0644	edit dl rm
sql_type_real.h	1257	0644	edit dl rm
sql_type_string.h	1629	0644	edit dl rm
sql_udf.h	4850	0644	edit dl rm
sql_union.h	1068	0644	edit dl rm
sql_update.h	1923	0644	edit dl rm
sql_view.h	2470	0644	edit dl rm
sql_window.h	6814	0644	edit dl rm
ssl_compat.h	3380	0644	edit dl rm
strfunc.h	2549	0644	edit dl rm
structs.h	29457	0644	edit dl rm
sys_vars_shared.h	2729	0644	edit dl rm
table.h	119009	0644	edit dl rm
table_cache.h	4232	0644	edit dl rm
threadpool.h	4810	0644	edit dl rm
threadpool_generic.h	3969	0644	edit dl rm
threadpool_winsockets.h	2290	0644	edit dl rm
thread_cache.h	5905	0644	edit dl rm
thr_alarm.h	2932	0644	edit dl rm
thr_lock.h	7350	0644	edit dl rm
thr_malloc.h	1202	0644	edit dl rm
thr_timer.h	1563	0644	edit dl rm
transaction.h	1466	0644	edit dl rm
tzfile.h	5014	0644	edit dl rm
tztime.h	3397	0644	edit dl rm
t_ctype.h	5639	0644	edit dl rm
uniques.h	4217	0644	edit dl rm
unireg.h	7722	0644	edit dl rm
vers_string.h	2543	0644	edit dl rm
violite.h	9956	0644	edit dl rm
waiting_threads.h	4532	0644	edit dl rm
welcome_copyright_notice.h	1218	0644	edit dl rm
winservice.h	6019	0644	edit dl rm
win_tzname_data.h	6506	0644	edit dl rm
wqueue.h	1565	0644	edit dl rm
wsrep.h	3308	0644	edit dl rm
wsrep_allowlist_service.h	1035	0644	edit dl rm
wsrep_applier.h	2703	0644	edit dl rm
wsrep_binlog.h	3551	0644	edit dl rm
wsrep_client_service.h	2602	0644	edit dl rm
wsrep_client_state.h	1566	0644	edit dl rm
wsrep_condition_variable.h	1484	0644	edit dl rm
wsrep_high_priority_service.h	4912	0644	edit dl rm
wsrep_mutex.h	1239	0644	edit dl rm
wsrep_mysqld.h	22006	0644	edit dl rm
wsrep_mysqld_c.h	1227	0644	edit dl rm
wsrep_on.h	1718	0644	edit dl rm
wsrep_priv.h	1634	0644	edit dl rm
wsrep_schema.h	5886	0644	edit dl rm
wsrep_server_service.h	3631	0644	edit dl rm
wsrep_server_state.h	2529	0644	edit dl rm
wsrep_sst.h	3951	0644	edit dl rm
wsrep_status.h	1816	0644	edit dl rm
wsrep_storage_service.h	1809	0644	edit dl rm
wsrep_thd.h	11487	0644	edit dl rm
wsrep_trans_observer.h	18174	0644	edit dl rm
wsrep_types.h	1110	0644	edit dl rm
wsrep_utils.h	10251	0644	edit dl rm
wsrep_var.h	4612	0644	edit dl rm
wsrep_xid.h	1509	0644	edit dl rm
xa.h	1845	0644	edit dl rm

Edit: /usr/include/mysql/server/private/item_timefunc.h (65896B)

#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-1335  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_ge0_func
{
  bool check_arguments() const override
  { return args[0]->check_type_can_return_date(func_name_cstring()); }
public:
  Item_long_func_date_field(THD *thd, Item *a)
   :Item_long_ge0_func(thd, a) { }
};

class Item_long_func_time_field: public Item_long_ge0_func
{
  bool check_arguments() const override
  { return args[0]->check_type_can_return_time(func_name_cstring()); }
public:
  Item_long_func_time_field(THD *thd, Item *a)
   :Item_long_ge0_func(thd, a) { }
};

class Item_func_period_add :public Item_long_func
{
  bool check_arguments() const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("period_add") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
    return FALSE;
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_period_add>(thd, this); }
};

class Item_func_period_diff :public Item_long_func
{
  bool check_arguments() const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("period_diff") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
    return FALSE;
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("to_days") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0; 
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  enum_monotonicity_info get_monotonicity_info() const override;
  longlong val_int_endpoint(bool left_endp, bool *incl_endp) override;
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_to_days>(thd, this); }
};

class Item_func_to_seconds :public Item_longlong_func
{
  bool check_arguments() const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("to_seconds") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0; 
    fix_char_length(12);
    set_maybe_null();
    return FALSE;
  }
  enum_monotonicity_info get_monotonicity_info() const override;
  longlong val_int_endpoint(bool left_endp, bool *incl_endp) override;
  bool check_partition_func_processor(void *bool_arg) override { return FALSE;}

/* Only meaningful with date part and optional time part */
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("dayofmonth") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0; 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_dayofmonth>(thd, this); }
};

class Item_func_month :public Item_long_ge0_func
{
public:
  Item_func_month(THD *thd, Item *a): Item_long_ge0_func(thd, a)
  { }
  longlong val_int() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("month") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals= 0;
    fix_char_length(2);
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("monthname") };
    return name;
  }
  String *val_str(String *str) override;
  bool fix_length_and_dec(THD *thd) override;
  bool check_partition_func_processor(void *int_arg) override {return TRUE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }
  bool check_vcol_func_processor(void *arg) override
  {
    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("dayofyear") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals= 0;
    fix_char_length(3);
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("hour") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_time_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("minute") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_time_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("quarter") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
     decimals=0;
     max_length=1*MY_CHARSET_BIN_MB_MAXLEN;
     set_maybe_null();
     return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("second") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_time_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_second>(thd, this); }
};

class Item_func_week :public Item_long_ge0_func
{
  bool check_arguments() const override
  {
    return args[0]->check_type_can_return_date(func_name_cstring()) ||
           (arg_count > 1 && args[1]->check_type_can_return_int(func_name_cstring()));
  }
public:
  Item_func_week(THD *thd, Item *a): Item_long_ge0_func(thd, a) {}
  Item_func_week(THD *thd, Item *a, Item *b): Item_long_ge0_func(thd, a, b) {}
  longlong val_int() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("week") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_vcol_func_processor(void *arg) override
  {
    if (arg_count == 2)
      return FALSE;
    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
  }
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return arg_count == 2;
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_week>(thd, this); }
};

class Item_func_yearweek :public Item_long_func
{
  bool check_arguments() const override
  {
    return args[0]->check_type_can_return_date(func_name_cstring()) ||
           args[1]->check_type_can_return_int(func_name_cstring());
  }
public:
  Item_func_yearweek(THD *thd, Item *a, Item *b)
   :Item_long_func(thd, a, b) {}
  longlong val_int() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("yearweek") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("year") };
    return name;
  }
  enum_monotonicity_info get_monotonicity_info() const override;
  longlong val_int_endpoint(bool left_endp, bool *incl_endp) override;
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    max_length=4*MY_CHARSET_BIN_MB_MAXLEN;
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_year>(thd, this); }
};

class Item_func_weekday :public Item_long_func
{
  bool odbc_type;
public:
  Item_func_weekday(THD *thd, Item *a, bool type_arg):
    Item_long_func(thd, a), odbc_type(type_arg) { }
  longlong val_int() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING dayofweek= {STRING_WITH_LEN("dayofweek") };
    static LEX_CSTRING weekday= {STRING_WITH_LEN("weekday") };
    return (odbc_type ? dayofweek : weekday);
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
  {
    return type_handler()->Item_get_date_with_warn(thd, this, ltime, fuzzydate);
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals= 0;
    fix_char_length(1);
    set_maybe_null();
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_weekday>(thd, this); }
};

class Item_func_dayname :public Item_str_func
{
  MY_LOCALE *locale;
 public:
  Item_func_dayname(THD *thd, Item *a): Item_str_func(thd, a) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("dayname") };
    return name;
  }
  String *val_str(String *str) override;
  const Type_handler *type_handler() const override
  { return &type_handler_varchar; }
  bool fix_length_and_dec(THD *thd) override;
  bool check_partition_func_processor(void *int_arg) override {return TRUE;}
  bool check_vcol_func_processor(void *arg) override
  {
    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
  }
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_date_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_dayname>(thd, this); }
};

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(decimal_digits_t dec)
  {
    DBUG_ASSERT(dec <= TIME_SECOND_PART_DIGITS);
    decimals= dec;
    max_length=17 + (decimals ? decimals + 1 : 0);
    set_maybe_null();
    if (decimals)
      set_handler(&type_handler_newdecimal);
    else
      set_handler(type_handler_long_or_longlong());
  }
  double real_op() override { DBUG_ASSERT(0); return 0; }
  String *str_op(String *str) override { DBUG_ASSERT(0); return 0; }
  bool date_op(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
  {
    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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("unix_timestamp") };
    return name;
  }
  enum_monotonicity_info get_monotonicity_info() const override;
  longlong val_int_endpoint(bool left_endp, bool *incl_endp) override;
  bool check_partition_func_processor(void *int_arg) override {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) override
  {
    return !has_timestamp_args();
  }
  bool check_vcol_func_processor(void *arg) override
  {
    if (arg_count)
      return FALSE;
    return mark_unsupported_function(func_name(), "()", arg, VCOL_TIME_FUNC);
  }
  bool fix_length_and_dec(THD *thd) override
  {
    fix_length_and_dec_generic(arg_count ?
                               args[0]->datetime_precision(thd) : 0);
    return FALSE;
  }
  longlong int_op() override;
  my_decimal *decimal_op(my_decimal* buf) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("time_to_sec") };
    return name;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_time_args();
  }
  bool fix_length_and_dec(THD *thd) override
  {
    fix_length_and_dec_generic(args[0]->time_precision(thd));
    return FALSE;
  }
  longlong int_op() override;
  my_decimal *decimal_op(my_decimal* buf) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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 override
  { return &type_handler_newdate; }
  longlong val_int() override
  {
    DBUG_ASSERT(!is_cond());
    return Date(this).to_longlong();
  }
  double val_real() override
  { return Date(this).to_double(); }
  String *val_str(String *to) override
  { return Date(this).to_string(to); }
  my_decimal *val_decimal(my_decimal *to) override
  { return Date(this).to_decimal(to); }
  bool fix_length_and_dec(THD *thd) override
  {
    fix_attributes_date();
    set_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 override
  { return &type_handler_time2; }
  longlong val_int() override
  {
    DBUG_ASSERT(!is_cond());
    return Time(this).to_longlong();
  }
  double val_real() override
  { return Time(this).to_double(); }
  String *val_str(String *to) override
  { return Time(this).to_string(to, decimals); }
  my_decimal *val_decimal(my_decimal *to) override
  { return Time(this).to_decimal(to); }
  bool val_native(THD *thd, Native *to) override
  { return Time(thd, this).to_native(to, decimals); }
};

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 override
  { return &type_handler_datetime2; }
  longlong val_int() override
  {
    DBUG_ASSERT(!is_cond());
    return Datetime(this).to_longlong();
  }
  double val_real() override { return Datetime(this).to_double(); }
  String *val_str(String *to) override
  { return Datetime(this).to_string(to, decimals); }
  my_decimal *val_decimal(my_decimal *to) override
  { 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, decimal_digits_t dec):
    Item_timefunc(thd), last_query_id(0)
  { decimals= dec; }
  bool fix_fields(THD *, Item **) override;
  bool fix_length_and_dec(THD *thd) override
  { fix_attributes_time(decimals); return FALSE; }
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
  /* 
    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) override
  {
    return mark_unsupported_function(func_name(), "()", arg, VCOL_TIME_FUNC);
  }
  void print(String *str, enum_query_type query_type) override;
};

class Item_func_curtime_local :public Item_func_curtime
{
public:
  Item_func_curtime_local(THD *thd, decimal_digits_t dec):
    Item_func_curtime(thd, dec) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("curtime") };
    return name;
  }
  void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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, decimal_digits_t dec):
    Item_func_curtime(thd, dec) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("utc_time") };
    return name;
  }
  void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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) override;
  virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time)=0;
  bool check_vcol_func_processor(void *arg) override
  {
    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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("curdate") };
    return name;
  }
  void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("utc_date") };
    return name;
  }
  void store_now_in_TIME(THD* thd, MYSQL_TIME *now_time) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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, decimal_digits_t dec):
    Item_datetimefunc(thd), last_query_id(0)
  { decimals= dec; }
  bool fix_fields(THD *, Item **) override;
  bool fix_length_and_dec(THD *thd) override
  { fix_attributes_datetime(decimals); return FALSE;}
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
  virtual void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time)=0;
  bool check_vcol_func_processor(void *arg) override
  {
    /*
      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) override;
};

class Item_func_now_local :public Item_func_now
{
public:
  Item_func_now_local(THD *thd, decimal_digits_t dec):
    Item_func_now(thd, dec) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("current_timestamp") };
    return name;
  }
  int save_in_field(Field *field, bool no_conversions) override;
  void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) override;
  enum Functype functype() const override { return NOW_FUNC; }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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, decimal_digits_t dec): Item_func_now(thd, dec) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("utc_timestamp") };
    return name;
  }
  void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) override;
  enum Functype functype() const override { return NOW_UTC_FUNC; }
  bool check_vcol_func_processor(void *arg) override
  {
    return mark_unsupported_function(func_name(), "()", arg,
                                     VCOL_TIME_FUNC | VCOL_NON_DETERMINISTIC);
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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, decimal_digits_t dec):
    Item_func_now(thd, dec) {}
  bool const_item() const override { return 0; }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("sysdate") };
    return name;
  }
  void store_now_in_TIME(THD *thd, MYSQL_TIME *now_time) override;
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
  table_map used_tables() const override { return RAND_TABLE_BIT; }
  bool check_vcol_func_processor(void *arg) override
  {
    return mark_unsupported_function(func_name(), "()", arg,
                                     VCOL_TIME_FUNC | VCOL_NON_DETERMINISTIC);
  }
  enum Functype functype() const override { return SYSDATE_FUNC; }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_sysdate_local>(thd, this); }
};

class Item_func_from_days :public Item_datefunc
{
  bool check_arguments() const override
  { return args[0]->check_type_can_return_int(func_name_cstring()); }
public:
  Item_func_from_days(THD *thd, Item *a): Item_datefunc(thd, a) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("from_days") };
    return name;
  }
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return has_date_args() || has_time_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_from_days>(thd, this); }
};

class Item_func_date_format :public Item_str_func
{
  bool check_arguments() const override
  {
    return args[0]->check_type_can_return_date(func_name_cstring()) ||
           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) override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("date_format") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override;
  uint format_length(const String *format);
  bool eq(const Item *item, const Eq_config &config) const override;
  bool check_vcol_func_processor(void *arg) override
  {
    if (arg_count > 2)
      return false;
    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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; }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("time_format") };
    return name;
  }
  bool check_vcol_func_processor(void *arg) override { return false; }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_time_format>(thd, this); }
};

/* the max length of datetime format models string in Oracle is 144 */
#define MAX_DATETIME_FORMAT_MODEL_LEN 144

class Item_func_tochar :public Item_str_func
{
  const MY_LOCALE *locale;
  THD *thd;
  String warning_message;
  bool fixed_length;

/*
    When datetime format models is parsed, use uint16 integers to
    represent the format models and store in fmt_array.
  */
  uint16 fmt_array[MAX_DATETIME_FORMAT_MODEL_LEN+1];

bool check_arguments() const override
  {
    return
      (args[0]->check_type_can_return_date(func_name_cstring()) &&
       args[0]->check_type_can_return_time(func_name_cstring())) ||
      check_argument_types_can_return_text(1, arg_count);
  }

public:
  Item_func_tochar(THD *thd, Item *a, Item *b):
    Item_str_func(thd, a, b), locale(0)
  {
    /* NOTE: max length of warning message is 64 */
    warning_message.alloc(64);
    warning_message.length(0);
  }
  ~Item_func_tochar() { warning_message.free(); }
  String *val_str(String *str) override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("to_char") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override;
  bool parse_format_string(const String *format, uint *fmt_len);

bool check_vcol_func_processor(void *arg) override
  {
    if (arg_count > 2)
      return false;
    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_tochar>(thd, this); }
};

class Item_func_from_unixtime :public Item_datetimefunc
{
  bool check_arguments() const override
  { return args[0]->check_type_can_return_decimal(func_name_cstring()); }
  Time_zone *tz;
 public:
  Item_func_from_unixtime(THD *thd, Item *a): Item_datetimefunc(thd, a) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("from_unixtime") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override;
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
  bool check_vcol_func_processor(void *arg) override
  {
    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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 override
  {
    return args[0]->check_type_can_return_date(func_name_cstring()) ||
           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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("convert_tz") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    fix_attributes_datetime(args[0]->datetime_precision(thd));
    set_maybe_null();
    return FALSE;
  }
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
  void cleanup() override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_convert_tz>(thd, this); }
};

class Item_func_sec_to_time :public Item_timefunc
{
  bool check_arguments() const override
  { return args[0]->check_type_can_return_decimal(func_name_cstring()); }
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) override;
  bool fix_length_and_dec(THD *thd) override
  {
    fix_attributes_time(args[0]->decimals);
    set_maybe_null();
    return FALSE;
  }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("sec_to_time") };
    return name;
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("date_add_interval") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override;
  bool eq(const Item *item, const Eq_config &config) const override;
  void print(String *str, enum_query_type query_type) override;
  enum precedence precedence() const override { return INTERVAL_PRECEDENCE; }
  bool need_parentheses_in_default() override { return true; }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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_slonglong;
    return &type_handler_slong;
  }
  void set_date_length(uint32 length)
  {
    /*
      DATE components (e.g. YEAR, YEAR_MONTH, QUARTER, MONTH, WEEK)
      return non-negative values but historically EXTRACT for date
      components always returned the signed int data type.
      So do equivalent functions YEAR(), QUARTER(), MONTH(), WEEK().
      Let's set the data type to "signed int, but not negative",
      so "this" produces better data types in VARCHAR and DECIMAL context
      by using the fact that all of the max_length characters are spent
      for digits (non of them are spent for the sign).
    */
    set_handler(&type_handler_slong_ge0);
    fix_char_length(length);
    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= Temporal::Options(TIME_INTERVAL_DAY, current_thd);
  }
  void set_time_length(uint32 length)
  {
    set_handler(handler_by_length(max_length= length + 1/*sign*/, 11));
    m_date_mode= Temporal::Options(TIME_INTERVAL_hhmmssff, current_thd);
  }
 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_slonglong),
    m_date_mode(date_mode_t(0)),
    int_type(type_arg)
  { }
  const Type_handler *type_handler() const override
  {
    return Type_handler_hybrid_field_type::type_handler();
  }
  longlong val_int() override;
  enum Functype functype() const override { return EXTRACT_FUNC; }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("extract") };
    return name;
  }
  bool check_arguments() const override;
  bool fix_length_and_dec(THD *thd) override;
  bool eq(const Item *item, const Eq_config &config) const override;
  void print(String *str, enum_query_type query_type) override;
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override
  {
    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) override
  {
    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;
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_extract>(thd, this); }
};

class Item_char_typecast :public Item_handled_func
{
  uint cast_length;
  CHARSET_INFO *cast_cs, *from_cs;
  bool charset_conversion;
  String tmp_value;
  bool m_suppress_warning_to_error_escalation;
public:
  bool has_explicit_length() const { return cast_length != ~0U; }
private:
  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:
  // Methods used by ColumnStore
  uint get_cast_length() const { return cast_length; }
public:
  Item_char_typecast(THD *thd, Item *a, uint length_arg, CHARSET_INFO *cs_arg):
    Item_handled_func(thd, a), cast_length(length_arg), cast_cs(cs_arg),
    m_suppress_warning_to_error_escalation(false) {}
  enum Functype functype() const override { return CHAR_TYPECAST_FUNC; }
  bool eq(const Item *item, const Eq_config &config) const override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("cast_as_char") };
    return name;
  }
  CHARSET_INFO *cast_charset() const { return cast_cs; }
  String *val_str_generic(String *a);
  String *val_str_binary_from_native(String *a);
  void fix_length_and_dec_generic();
  void fix_length_and_dec_numeric();
  void fix_length_and_dec_str();
  void fix_length_and_dec_native_to_binary(uint32 octet_length);
  bool fix_length_and_dec(THD *thd) override
  {
    return args[0]->type_handler()->Item_char_typecast_fix_length_and_dec(this);
  }
  void print(String *str, enum_query_type query_type) override;
  bool need_parentheses_in_default() override { return true; }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_char_typecast>(thd, this); }
};

class Item_interval_DDhhmmssff_typecast :public Item_char_typecast
{
  uint m_fsp;
public:
  Item_interval_DDhhmmssff_typecast(THD *thd, Item *a, uint fsp)
   :Item_char_typecast(thd, a,Interval_DDhhmmssff::max_char_length(fsp),
                       &my_charset_latin1),
    m_fsp(fsp)
  { }
  String *val_str(String *to) override
  {
    Interval_DDhhmmssff it(current_thd, args[0], m_fsp);
    null_value= !it.is_valid_interval_DDhhmmssff();
    return it.to_string(to, m_fsp);
  }
};

class Item_date_typecast :public Item_datefunc
{
public:
  Item_date_typecast(THD *thd, Item *a): Item_datefunc(thd, a) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("cast_as_date") };
    return name;
  }
  void print(String *str, enum_query_type query_type) override
  {
    print_cast_temporal(str, query_type);
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
  bool fix_length_and_dec(THD *thd) override
  {
    return args[0]->type_handler()->Item_date_typecast_fix_length_and_dec(this);
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_date_typecast>(thd, this); }
};

class Item_time_typecast :public Item_timefunc
{
public:
  Item_time_typecast(THD *thd, Item *a, decimal_digits_t dec_arg):
    Item_timefunc(thd, a) { decimals= dec_arg; }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("cast_as_time") };
    return name;
  }
  void print(String *str, enum_query_type query_type) override
  {
    print_cast_temporal(str, query_type);
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
  bool fix_length_and_dec(THD *thd) override
  {
    return args[0]->type_handler()->
           Item_time_typecast_fix_length_and_dec(this);
  }
  Sql_mode_dependency value_depends_on_sql_mode() const override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_time_typecast>(thd, this); }
};

class Item_datetime_typecast :public Item_datetimefunc
{
public:
  Item_datetime_typecast(THD *thd, Item *a, decimal_digits_t dec_arg):
    Item_datetimefunc(thd, a) { decimals= dec_arg; }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("cast_as_datetime") };
    return name;
  }
  void print(String *str, enum_query_type query_type) override
  {
    print_cast_temporal(str, query_type);
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
  bool fix_length_and_dec(THD *thd) override
  {
    return args[0]->type_handler()->
           Item_datetime_typecast_fix_length_and_dec(this);
  }
  Sql_mode_dependency value_depends_on_sql_mode() const override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_datetime_typecast>(thd, this); }
};

class Item_func_makedate :public Item_datefunc
{
  bool check_arguments() const override
  { 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("makedate") };
    return name;
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_makedate>(thd, this); }
};

class Item_func_timestamp :public Item_datetimefunc
{
  bool check_arguments() const override
  {
    return args[0]->check_type_can_return_date(func_name_cstring()) ||
           args[1]->check_type_can_return_time(func_name_cstring());
  }
public:
  Item_func_timestamp(THD *thd, Item *a, Item *b)
   :Item_datetimefunc(thd, a, b)
  { }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("timestamp") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimal_digits_t dec0= args[0]->datetime_precision(thd);
    decimal_digits_t dec1= Interval_DDhhmmssff::fsp(thd, args[1]);
    fix_attributes_datetime(MY_MAX(dec0, dec1));
    set_maybe_null();
    return false;
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
  {
    Datetime dt(thd, args[0], Datetime::Options(TIME_CONV_NONE, thd));
    if (!dt.is_valid_datetime())
      return (null_value= 1);

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));
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { 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:
  // Methods used by ColumnStore
  int get_sign() const { return 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(THD *thd) override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING addtime= { STRING_WITH_LEN("addtime") };
    static LEX_CSTRING subtime= { STRING_WITH_LEN("subtime") };
    return sign > 0 ? addtime : subtime;
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_add_time>(thd, this); }
};

class Item_func_timediff :public Item_timefunc
{
  bool check_arguments() const override
  { 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("timediff") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimal_digits_t dec= MY_MAX(args[0]->time_precision(thd),
                                 args[1]->time_precision(thd));
    fix_attributes_time(dec);
    set_maybe_null();
    return FALSE;
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_timediff>(thd, this); }
};

class Item_func_maketime :public Item_timefunc
{
  bool check_arguments() const override
  {
    return check_argument_types_can_return_int(0, 2) ||
           args[2]->check_type_can_return_decimal(func_name_cstring());
  }
public:
  Item_func_maketime(THD *thd, Item *a, Item *b, Item *c):
    Item_timefunc(thd, a, b, c)
  {}
  bool fix_length_and_dec(THD *thd) override
  {
    fix_attributes_time(args[2]->decimals);
    set_maybe_null();
    return FALSE;
  }
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("maketime") };
    return name;
  }
  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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() override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("microsecond") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    set_maybe_null();
    fix_char_length(6);
    return FALSE;
  }
  bool check_partition_func_processor(void *int_arg) override {return FALSE;}
  bool check_vcol_func_processor(void *arg) override { return FALSE;}
  bool check_valid_arguments_processor(void *int_arg) override
  {
    return !has_time_args();
  }

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_microsecond>(thd, this); }
};

class Item_func_timestamp_diff :public Item_longlong_func
{
  bool check_arguments() const override
  { return check_argument_types_can_return_date(0, arg_count); }
  const interval_type int_type;
public:
  // Methods used by ColumnStore
  interval_type get_int_type() const { return 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) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("timestampdiff") };
    return name;
  }
  longlong val_int() override;
  bool fix_length_and_dec(THD *thd) override
  {
    decimals=0;
    set_maybe_null();
    return FALSE;
  }
  void print(String *str, enum_query_type query_type) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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) override;
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("get_format") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override
  {
    set_maybe_null();
    decimals=0;
    fix_length_and_charset(17, default_charset());
    return FALSE;
  }
  void print(String *str, enum_query_type query_type) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { 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);
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("str_to_date") };
    return name;
  }
  bool fix_length_and_dec(THD *thd) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_str_to_date>(thd, this); }
};

class Item_func_last_day :public Item_datefunc
{
  bool check_arguments() const override
  { return args[0]->check_type_can_return_date(func_name_cstring()); }
public:
  Item_func_last_day(THD *thd, Item *a): Item_datefunc(thd, a) {}
  LEX_CSTRING func_name_cstring() const override
  {
    static LEX_CSTRING name= {STRING_WITH_LEN("last_day") };
    return name;
  }
  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;

protected:
  Item *shallow_copy(THD *thd) const override
  { return get_item_copy<Item_func_last_day>(thd, this); }
};

/*****************************************************************************/

class Func_handler_date_add_interval
{
protected:
  static decimal_digits_t 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 override
  {
    decimal_digits_t 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 override
  {
    Datetime::Options opt(TIME_CONV_NONE, thd);
    Datetime dt(thd, item->arguments()[0], opt);
    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 override;
};

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 override
  {
    /*
      The first argument is known to be of the DATE data type (not DATETIME).
      We don't need rounding here.
    */
    Date d(thd, item->arguments()[0], TIME_CONV_NONE);
    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 override
  {
    decimal_digits_t 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 override
  {
    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 override
  {
    decimal_digits_t dec=
      MY_MAX(item->arguments()[0]->datetime_precision(current_thd),
             interval_dec(item->arguments()[1], int_type(item)));
    item->Type_std_attributes::set(
      Type_temporal_attributes_not_fixed_dec(MAX_DATETIME_WIDTH, dec, false),
      DTCollation(item->default_charset(),
                  DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII));
    item->fix_char_length(item->max_length);
    return false;
  }
  bool get_date(THD *thd, Item_handled_func *item,
                MYSQL_TIME *to, date_mode_t fuzzy) const override
  {
    if (item->arguments()[0]->
          get_date(thd, to, Datetime::Options(TIME_CONV_NONE, thd)) ||
        (to->time_type != MYSQL_TIMESTAMP_TIME &&
         check_date_with_warn(thd, to, TIME_NO_ZEROS, 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 override
  {
    THD *thd= current_thd;
    decimal_digits_t dec0= item->arguments()[0]->datetime_precision(thd);
    decimal_digits_t 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 override
  {
    DBUG_ASSERT(item->fixed());
    Datetime::Options opt(TIME_CONV_NONE, thd);
    Datetime dt(thd, item->arguments()[0], opt);
    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 override
  {
    THD *thd= current_thd;
    decimal_digits_t dec0= item->arguments()[0]->time_precision(thd);
    decimal_digits_t 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 override
  {
    DBUG_ASSERT(item->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 override
  {
    decimal_digits_t dec0= item->arguments()[0]->decimals;
    decimal_digits_t dec1=
      Interval_DDhhmmssff::fsp(current_thd, item->arguments()[1]);
    decimal_digits_t dec= MY_MAX(dec0, dec1);
    item->Type_std_attributes::set(
      Type_temporal_attributes_not_fixed_dec(MAX_DATETIME_WIDTH, dec, false),
      DTCollation(item->default_charset(),
                  DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII));
    item->fix_char_length(item->max_length);
    return false;
  }
  bool get_date(THD *thd, Item_handled_func *item,
                MYSQL_TIME *to, date_mode_t fuzzy) const override
  {
    DBUG_ASSERT(item->fixed());
    // Detect a proper timestamp type based on the argument values
    Temporal_hybrid l_time1(thd, item->arguments()[0],
                            Temporal::Options(TIME_TIME_ONLY, thd));
    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 override
  {
    item->fix_attributes_datetime(0);
    return false;
  }
  bool get_date(THD *thd, Item_handled_func *item,
                MYSQL_TIME *to, date_mode_t fuzzy) const override
  {
    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 override
  {
    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 override
  {
    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 override
  {
    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 override
  {
    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 override
  {
    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 override
  {
    item->fix_attributes_time(TIME_SECOND_PART_DIGITS);
    return false;
  }
};

#endif /* ITEM_TIMEFUNC_INCLUDED */

cmd: