summaryrefslogtreecommitdiffstats
path: root/sql/item.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:07:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:07:14 +0000
commita175314c3e5827eb193872241446f2f8f5c9d33c (patch)
treecd3d60ca99ae00829c52a6ca79150a5b6e62528b /sql/item.h
parentInitial commit. (diff)
downloadmariadb-10.5-a175314c3e5827eb193872241446f2f8f5c9d33c.tar.xz
mariadb-10.5-a175314c3e5827eb193872241446f2f8f5c9d33c.zip
Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sql/item.h')
-rw-r--r--sql/item.h7593
1 files changed, 7593 insertions, 0 deletions
diff --git a/sql/item.h b/sql/item.h
new file mode 100644
index 00000000..2720ddde
--- /dev/null
+++ b/sql/item.h
@@ -0,0 +1,7593 @@
+#ifndef SQL_ITEM_INCLUDED
+#define SQL_ITEM_INCLUDED
+
+/* Copyright (c) 2000, 2017, Oracle and/or its affiliates.
+ Copyright (c) 2009, 2021, MariaDB Corporation.
+
+ 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 */
+
+
+#ifdef USE_PRAGMA_INTERFACE
+#pragma interface /* gcc class implementation */
+#endif
+
+#include "sql_priv.h" /* STRING_BUFFER_USUAL_SIZE */
+#include "unireg.h"
+#include "sql_const.h" /* RAND_TABLE_BIT, MAX_FIELD_NAME */
+#include "field.h" /* Derivation */
+#include "sql_type.h"
+#include "sql_time.h"
+#include "mem_root_array.h"
+
+C_MODE_START
+#include <ma_dyncol.h>
+
+/*
+ A prototype for a C-compatible structure to store a value of any data type.
+ Currently it has to stay in /sql, as it depends on String and my_decimal.
+ We'll do the following changes:
+ 1. add pure C "struct st_string" and "struct st_my_decimal"
+ 2. change type of m_string to struct st_string and move inside the union
+ 3. change type of m_decmal to struct st_my_decimal and move inside the union
+ 4. move the definition to some file in /include
+*/
+struct st_value
+{
+ enum enum_dynamic_column_type m_type;
+ union
+ {
+ longlong m_longlong;
+ double m_double;
+ MYSQL_TIME m_time;
+ } value;
+ String m_string;
+ my_decimal m_decimal;
+};
+
+C_MODE_END
+
+
+class Value: public st_value
+{
+public:
+ bool is_null() const { return m_type == DYN_COL_NULL; }
+ bool is_longlong() const
+ {
+ return m_type == DYN_COL_UINT || m_type == DYN_COL_INT;
+ }
+ bool is_double() const { return m_type == DYN_COL_DOUBLE; }
+ bool is_temporal() const { return m_type == DYN_COL_DATETIME; }
+ bool is_string() const { return m_type == DYN_COL_STRING; }
+ bool is_decimal() const { return m_type == DYN_COL_DECIMAL; }
+};
+
+
+template<size_t buffer_size>
+class ValueBuffer: public Value
+{
+ char buffer[buffer_size];
+ void reset_buffer()
+ {
+ m_string.set(buffer, buffer_size, &my_charset_bin);
+ }
+public:
+ ValueBuffer()
+ {
+ reset_buffer();
+ }
+};
+
+
+#ifdef DBUG_OFF
+static inline const char *dbug_print_item(Item *item) { return NULL; }
+#else
+const char *dbug_print_item(Item *item);
+#endif
+
+class Virtual_tmp_table;
+class sp_head;
+class Protocol;
+struct TABLE_LIST;
+void item_init(void); /* Init item functions */
+class Item_basic_value;
+class Item_result_field;
+class Item_field;
+class Item_ref;
+class Item_param;
+class user_var_entry;
+class JOIN;
+struct KEY_FIELD;
+struct SARGABLE_PARAM;
+class RANGE_OPT_PARAM;
+class SEL_TREE;
+class With_sum_func_cache;
+
+enum precedence {
+ LOWEST_PRECEDENCE,
+ ASSIGN_PRECEDENCE, // :=
+ OR_PRECEDENCE, // OR, || (unless PIPES_AS_CONCAT)
+ XOR_PRECEDENCE, // XOR
+ AND_PRECEDENCE, // AND, &&
+ NOT_PRECEDENCE, // NOT (unless HIGH_NOT_PRECEDENCE)
+ CMP_PRECEDENCE, // =, <=>, >=, >, <=, <, <>, !=, IS
+ BETWEEN_PRECEDENCE, // BETWEEN
+ IN_PRECEDENCE, // IN, LIKE, REGEXP
+ BITOR_PRECEDENCE, // |
+ BITAND_PRECEDENCE, // &
+ SHIFT_PRECEDENCE, // <<, >>
+ INTERVAL_PRECEDENCE, // first argument in +INTERVAL
+ ADD_PRECEDENCE, // +, -
+ MUL_PRECEDENCE, // *, /, DIV, %, MOD
+ BITXOR_PRECEDENCE, // ^
+ PIPES_PRECEDENCE, // || (if PIPES_AS_CONCAT)
+ NEG_PRECEDENCE, // unary -, ~, !, NOT (if HIGH_NOT_PRECEDENCE)
+ COLLATE_PRECEDENCE, // BINARY, COLLATE
+ DEFAULT_PRECEDENCE,
+ HIGHEST_PRECEDENCE
+};
+
+bool mark_unsupported_function(const char *where, void *store, uint result);
+
+/* convenience helper for mark_unsupported_function() above */
+bool mark_unsupported_function(const char *w1, const char *w2,
+ void *store, uint result);
+
+/* Bits for the split_sum_func() function */
+#define SPLIT_SUM_SKIP_REGISTERED 1 /* Skip registered funcs */
+#define SPLIT_SUM_SELECT 2 /* SELECT item; Split all parts */
+
+
+#define NO_EXTRACTION_FL (1 << 6)
+#define FULL_EXTRACTION_FL (1 << 7)
+#define DELETION_FL (1 << 8)
+#define IMMUTABLE_FL (1 << 9)
+#define SUBSTITUTION_FL (1 << 10)
+#define EXTRACTION_MASK \
+ (NO_EXTRACTION_FL | FULL_EXTRACTION_FL | DELETION_FL | IMMUTABLE_FL)
+
+extern const char *item_empty_name;
+
+void dummy_error_processor(THD *thd, void *data);
+
+void view_error_processor(THD *thd, void *data);
+
+/*
+ Instances of Name_resolution_context store the information necessary for
+ name resolution of Items and other context analysis of a query made in
+ fix_fields().
+
+ This structure is a part of SELECT_LEX, a pointer to this structure is
+ assigned when an item is created (which happens mostly during parsing
+ (sql_yacc.yy)), but the structure itself will be initialized after parsing
+ is complete
+
+ TODO: move subquery of INSERT ... SELECT and CREATE ... SELECT to
+ separate SELECT_LEX which allow to remove tricks of changing this
+ structure before and after INSERT/CREATE and its SELECT to make correct
+ field name resolution.
+*/
+struct Name_resolution_context: Sql_alloc
+{
+ /*
+ The name resolution context to search in when an Item cannot be
+ resolved in this context (the context of an outer select)
+ */
+ Name_resolution_context *outer_context;
+
+ /*
+ List of tables used to resolve the items of this context. Usually these
+ are tables from the FROM clause of SELECT statement. The exceptions are
+ INSERT ... SELECT and CREATE ... SELECT statements, where SELECT
+ subquery is not moved to a separate SELECT_LEX. For these types of
+ statements we have to change this member dynamically to ensure correct
+ name resolution of different parts of the statement.
+ */
+ TABLE_LIST *table_list;
+ /*
+ In most cases the two table references below replace 'table_list' above
+ for the purpose of name resolution. The first and last name resolution
+ table references allow us to search only in a sub-tree of the nested
+ join tree in a FROM clause. This is needed for NATURAL JOIN, JOIN ... USING
+ and JOIN ... ON.
+ */
+ TABLE_LIST *first_name_resolution_table;
+ /*
+ Last table to search in the list of leaf table references that begins
+ with first_name_resolution_table.
+ */
+ TABLE_LIST *last_name_resolution_table;
+
+ /* Cache first_name_resolution_table in setup_natural_join_row_types */
+ TABLE_LIST *natural_join_first_table;
+ /*
+ SELECT_LEX item belong to, in case of merged VIEW it can differ from
+ SELECT_LEX where item was created, so we can't use table_list/field_list
+ from there
+ */
+ st_select_lex *select_lex;
+
+ /*
+ Processor of errors caused during Item name resolving, now used only to
+ hide underlying tables in errors about views (i.e. it substitute some
+ errors for views)
+ */
+ void (*error_processor)(THD *, void *);
+ void *error_processor_data;
+
+ /*
+ When TRUE items are resolved in this context both against the
+ SELECT list and this->table_list. If FALSE, items are resolved
+ only against this->table_list.
+ */
+ bool resolve_in_select_list;
+
+ /*
+ Security context of this name resolution context. It's used for views
+ and is non-zero only if the view is defined with SQL SECURITY DEFINER.
+ */
+ Security_context *security_ctx;
+
+ Name_resolution_context()
+ :outer_context(0), table_list(0), select_lex(0),
+ error_processor_data(0),
+ security_ctx(0)
+ {}
+
+ void init()
+ {
+ resolve_in_select_list= FALSE;
+ error_processor= &dummy_error_processor;
+ first_name_resolution_table= NULL;
+ last_name_resolution_table= NULL;
+ }
+
+ void resolve_in_table_list_only(TABLE_LIST *tables)
+ {
+ table_list= first_name_resolution_table= tables;
+ resolve_in_select_list= FALSE;
+ }
+
+ void process_error(THD *thd)
+ {
+ (*error_processor)(thd, error_processor_data);
+ }
+ st_select_lex *outer_select()
+ {
+ return (outer_context ?
+ outer_context->select_lex :
+ NULL);
+ }
+};
+
+
+/*
+ Store and restore the current state of a name resolution context.
+*/
+
+class Name_resolution_context_state
+{
+private:
+ TABLE_LIST *save_table_list;
+ TABLE_LIST *save_first_name_resolution_table;
+ TABLE_LIST *save_next_name_resolution_table;
+ bool save_resolve_in_select_list;
+ TABLE_LIST *save_next_local;
+
+public:
+ Name_resolution_context_state() {} /* Remove gcc warning */
+
+public:
+ /* Save the state of a name resolution context. */
+ void save_state(Name_resolution_context *context, TABLE_LIST *table_list)
+ {
+ save_table_list= context->table_list;
+ save_first_name_resolution_table= context->first_name_resolution_table;
+ save_resolve_in_select_list= context->resolve_in_select_list;
+ save_next_local= table_list->next_local;
+ save_next_name_resolution_table= table_list->next_name_resolution_table;
+ }
+
+ /* Restore a name resolution context from saved state. */
+ void restore_state(Name_resolution_context *context, TABLE_LIST *table_list)
+ {
+ table_list->next_local= save_next_local;
+ table_list->next_name_resolution_table= save_next_name_resolution_table;
+ context->table_list= save_table_list;
+ context->first_name_resolution_table= save_first_name_resolution_table;
+ context->resolve_in_select_list= save_resolve_in_select_list;
+ }
+
+ TABLE_LIST *get_first_name_resolution_table()
+ {
+ return save_first_name_resolution_table;
+ }
+};
+
+class Name_resolution_context_backup
+{
+ Name_resolution_context &ctx;
+ TABLE_LIST &table_list;
+ table_map save_map;
+ Name_resolution_context_state ctx_state;
+
+public:
+ Name_resolution_context_backup(Name_resolution_context &_ctx, TABLE_LIST &_table_list)
+ : ctx(_ctx), table_list(_table_list), save_map(_table_list.map)
+ {
+ ctx_state.save_state(&ctx, &table_list);
+ ctx.table_list= &table_list;
+ ctx.first_name_resolution_table= &table_list;
+ }
+ ~Name_resolution_context_backup()
+ {
+ ctx_state.restore_state(&ctx, &table_list);
+ table_list.map= save_map;
+ }
+};
+
+
+/*
+ This enum is used to report information about monotonicity of function
+ represented by Item* tree.
+ Monotonicity is defined only for Item* trees that represent table
+ partitioning expressions (i.e. have no subselects/user vars/PS parameters
+ etc etc). An Item* tree is assumed to have the same monotonicity properties
+ as its corresponding function F:
+
+ [signed] longlong F(field1, field2, ...) {
+ put values of field_i into table record buffer;
+ return item->val_int();
+ }
+
+ NOTE
+ At the moment function monotonicity is not well defined (and so may be
+ incorrect) for Item trees with parameters/return types that are different
+ from INT_RESULT, may be NULL, or are unsigned.
+ It will be possible to address this issue once the related partitioning bugs
+ (BUG#16002, BUG#15447, BUG#13436) are fixed.
+
+ The NOT_NULL enums are used in TO_DAYS, since TO_DAYS('2001-00-00') returns
+ NULL which puts those rows into the NULL partition, but
+ '2000-12-31' < '2001-00-00' < '2001-01-01'. So special handling is needed
+ for this (see Bug#20577).
+*/
+
+typedef enum monotonicity_info
+{
+ NON_MONOTONIC, /* none of the below holds */
+ MONOTONIC_INCREASING, /* F() is unary and (x < y) => (F(x) <= F(y)) */
+ MONOTONIC_INCREASING_NOT_NULL, /* But only for valid/real x and y */
+ MONOTONIC_STRICT_INCREASING,/* F() is unary and (x < y) => (F(x) < F(y)) */
+ MONOTONIC_STRICT_INCREASING_NOT_NULL /* But only for valid/real x and y */
+} enum_monotonicity_info;
+
+/*************************************************************************/
+
+class sp_rcontext;
+
+/**
+ A helper class to collect different behavior of various kinds of SP variables:
+ - local SP variables and SP parameters
+ - PACKAGE BODY routine variables
+ - (there will be more kinds in the future)
+*/
+
+class Sp_rcontext_handler
+{
+public:
+ virtual ~Sp_rcontext_handler() {}
+ /**
+ A prefix used for SP variable names in queries:
+ - EXPLAIN EXTENDED
+ - SHOW PROCEDURE CODE
+ Local variables and SP parameters have empty prefixes.
+ Package body variables are marked with a special prefix.
+ This improves readability of the output of these queries,
+ especially when a local variable or a parameter has the same
+ name with a package body variable.
+ */
+ virtual const LEX_CSTRING *get_name_prefix() const= 0;
+ /**
+ At execution time THD->spcont points to the run-time context (sp_rcontext)
+ of the currently executed routine.
+ Local variables store their data in the sp_rcontext pointed by thd->spcont.
+ Package body variables store data in separate sp_rcontext that belongs
+ to the package.
+ This method provides access to the proper sp_rcontext structure,
+ depending on the SP variable kind.
+ */
+ virtual sp_rcontext *get_rcontext(sp_rcontext *ctx) const= 0;
+};
+
+
+class Sp_rcontext_handler_local: public Sp_rcontext_handler
+{
+public:
+ const LEX_CSTRING *get_name_prefix() const;
+ sp_rcontext *get_rcontext(sp_rcontext *ctx) const;
+};
+
+
+class Sp_rcontext_handler_package_body: public Sp_rcontext_handler
+{
+public:
+ const LEX_CSTRING *get_name_prefix() const;
+ sp_rcontext *get_rcontext(sp_rcontext *ctx) const;
+};
+
+
+extern MYSQL_PLUGIN_IMPORT
+ Sp_rcontext_handler_local sp_rcontext_handler_local;
+
+
+extern MYSQL_PLUGIN_IMPORT
+ Sp_rcontext_handler_package_body sp_rcontext_handler_package_body;
+
+
+
+class Item_equal;
+
+struct st_join_table* const NO_PARTICULAR_TAB= (struct st_join_table*)0x1;
+
+typedef struct replace_equal_field_arg
+{
+ Item_equal *item_equal;
+ struct st_join_table *context_tab;
+} REPLACE_EQUAL_FIELD_ARG;
+
+class Settable_routine_parameter
+{
+public:
+ /*
+ Set required privileges for accessing the parameter.
+
+ SYNOPSIS
+ set_required_privilege()
+ rw if 'rw' is true then we are going to read and set the
+ parameter, so SELECT and UPDATE privileges might be
+ required, otherwise we only reading it and SELECT
+ privilege might be required.
+ */
+ Settable_routine_parameter() {}
+ virtual ~Settable_routine_parameter() {}
+ virtual void set_required_privilege(bool rw) {};
+
+ /*
+ Set parameter value.
+
+ SYNOPSIS
+ set_value()
+ thd thread handle
+ ctx context to which parameter belongs (if it is local
+ variable).
+ it item which represents new value
+
+ RETURN
+ FALSE if parameter value has been set,
+ TRUE if error has occurred.
+ */
+ virtual bool set_value(THD *thd, sp_rcontext *ctx, Item **it)= 0;
+
+ virtual void set_out_param_info(Send_field *info) {}
+
+ virtual const Send_field *get_out_param_info() const
+ { return NULL; }
+
+ virtual Item_param *get_item_param() { return 0; }
+};
+
+
+/*
+ A helper class to calculate offset and length of a query fragment
+ - outside of SP
+ - inside an SP
+ - inside a compound block
+*/
+class Query_fragment
+{
+ uint m_pos;
+ uint m_length;
+ void set(size_t pos, size_t length)
+ {
+ DBUG_ASSERT(pos < UINT_MAX32);
+ DBUG_ASSERT(length < UINT_MAX32);
+ m_pos= (uint) pos;
+ m_length= (uint) length;
+ }
+public:
+ Query_fragment(THD *thd, sp_head *sphead, const char *start, const char *end);
+ uint pos() const { return m_pos; }
+ uint length() const { return m_length; }
+};
+
+
+/**
+ This is used for items in the query that needs to be rewritten
+ before binlogging
+
+ At the moment this applies to Item_param and Item_splocal
+*/
+class Rewritable_query_parameter
+{
+ public:
+ /*
+ Offset inside the query text.
+ Value of 0 means that this object doesn't have to be replaced
+ (for example SP variables in control statements)
+ */
+ my_ptrdiff_t pos_in_query;
+
+ /*
+ Byte length of parameter name in the statement. This is not
+ Item::name.length because name.length contains byte length of UTF8-encoded
+ name, but the query string is in the client charset.
+ */
+ uint len_in_query;
+
+ bool limit_clause_param;
+
+ Rewritable_query_parameter(uint pos_in_q= 0, uint len_in_q= 0)
+ : pos_in_query(pos_in_q), len_in_query(len_in_q),
+ limit_clause_param(false)
+ { }
+
+ virtual ~Rewritable_query_parameter() { }
+
+ virtual bool append_for_log(THD *thd, String *str) = 0;
+};
+
+class Copy_query_with_rewrite
+{
+ THD *thd;
+ const char *src;
+ size_t src_len, from;
+ String *dst;
+
+ bool copy_up_to(size_t bytes)
+ {
+ DBUG_ASSERT(bytes >= from);
+ return dst->append(src + from, uint32(bytes - from));
+ }
+
+public:
+
+ Copy_query_with_rewrite(THD *t, const char *s, size_t l, String *d)
+ :thd(t), src(s), src_len(l), from(0), dst(d) { }
+
+ bool append(Rewritable_query_parameter *p)
+ {
+ if (copy_up_to(p->pos_in_query) || p->append_for_log(thd, dst))
+ return true;
+ from= p->pos_in_query + p->len_in_query;
+ return false;
+ }
+
+ bool finalize()
+ { return copy_up_to(src_len); }
+};
+
+struct st_dyncall_create_def
+{
+ Item *key, *value;
+ CHARSET_INFO *cs;
+ uint len, frac;
+ DYNAMIC_COLUMN_TYPE type;
+};
+
+typedef struct st_dyncall_create_def DYNCALL_CREATE_DEF;
+
+
+typedef bool (Item::*Item_processor) (void *arg);
+/*
+ Analyzer function
+ SYNOPSIS
+ argp in/out IN: Analysis parameter
+ OUT: Parameter to be passed to the transformer
+
+ RETURN
+ TRUE Invoke the transformer
+ FALSE Don't do it
+
+*/
+typedef bool (Item::*Item_analyzer) (uchar **argp);
+typedef Item* (Item::*Item_transformer) (THD *thd, uchar *arg);
+typedef void (*Cond_traverser) (const Item *item, void *arg);
+typedef bool (Item::*Pushdown_checker) (uchar *arg);
+
+struct st_cond_statistic;
+
+struct find_selective_predicates_list_processor_data
+{
+ TABLE *table;
+ List<st_cond_statistic> list;
+};
+
+class MY_LOCALE;
+
+class Item_equal;
+class COND_EQUAL;
+
+class st_select_lex_unit;
+
+class Item_func_not;
+class Item_splocal;
+
+/* Item::common_flags */
+/* Indicates that name of this Item autogenerated or set by user */
+#define IS_AUTO_GENERATED_NAME 1
+/* Indicates that this item is in CYCLE clause of WITH */
+#define IS_IN_WITH_CYCLE 2
+
+
+/**
+ String_copier that sends Item specific warnings.
+*/
+class String_copier_for_item: public String_copier
+{
+ THD *m_thd;
+public:
+ bool copy_with_warn(CHARSET_INFO *dstcs, String *dst,
+ CHARSET_INFO *srccs, const char *src,
+ uint32 src_length, uint32 nchars);
+ String_copier_for_item(THD *thd): m_thd(thd) { }
+};
+
+
+/**
+ A helper class describing what kind of Item created a temporary field.
+ - If m_field is set, then the temporary field was created from Field
+ (e.g. when the Item was Item_field, or Item_ref pointing to Item_field)
+ - If m_default_field is set, then there is a usable DEFAULT value.
+ (e.g. when the Item is Item_field)
+ - If m_item_result_field is set, then the temporary field was created
+ from certain sub-types of Item_result_field (e.g. Item_func)
+ See create_tmp_field() in sql_select.cc for details.
+*/
+
+class Tmp_field_src
+{
+ Field *m_field;
+ Field *m_default_field;
+ Item_result_field *m_item_result_field;
+public:
+ Tmp_field_src()
+ :m_field(0),
+ m_default_field(0),
+ m_item_result_field(0)
+ { }
+ Field *field() const { return m_field; }
+ Field *default_field() const { return m_default_field; }
+ Item_result_field *item_result_field() const { return m_item_result_field; }
+ void set_field(Field *field) { m_field= field; }
+ void set_default_field(Field *field) { m_default_field= field; }
+ void set_item_result_field(Item_result_field *item)
+ { m_item_result_field= item; }
+};
+
+
+/**
+ Parameters for create_tmp_field_ex().
+ See create_tmp_field() in sql_select.cc for details.
+*/
+
+class Tmp_field_param
+{
+ bool m_group;
+ bool m_modify_item;
+ bool m_table_cant_handle_bit_fields;
+ bool m_make_copy_field;
+public:
+ Tmp_field_param(bool group,
+ bool modify_item,
+ bool table_cant_handle_bit_fields,
+ bool make_copy_field)
+ :m_group(group),
+ m_modify_item(modify_item),
+ m_table_cant_handle_bit_fields(table_cant_handle_bit_fields),
+ m_make_copy_field(make_copy_field)
+ { }
+ bool group() const { return m_group; }
+ bool modify_item() const { return m_modify_item; }
+ bool table_cant_handle_bit_fields() const
+ { return m_table_cant_handle_bit_fields; }
+ bool make_copy_field() const { return m_make_copy_field; }
+ void set_modify_item(bool to) { m_modify_item= to; }
+};
+
+
+class Item_const
+{
+public:
+ virtual ~Item_const() {}
+ virtual const Type_all_attributes *get_type_all_attributes_from_const() const= 0;
+ virtual bool const_is_null() const { return false; }
+ virtual const longlong *const_ptr_longlong() const { return NULL; }
+ virtual const double *const_ptr_double() const { return NULL; }
+ virtual const my_decimal *const_ptr_my_decimal() const { return NULL; }
+ virtual const MYSQL_TIME *const_ptr_mysql_time() const { return NULL; }
+ virtual const String *const_ptr_string() const { return NULL; }
+};
+
+
+/****************************************************************************/
+
+#define STOP_PTR ((void *) 1)
+
+class Item: public Value_source,
+ public Type_all_attributes
+{
+ /**
+ The index in the JOIN::join_tab array of the JOIN_TAB this Item is attached
+ to. Items are attached (or 'pushed') to JOIN_TABs during optimization by the
+ make_cond_for_table procedure. During query execution, this item is
+ evaluated when the join loop reaches the corresponding JOIN_TAB.
+
+ If the value of join_tab_idx >= MAX_TABLES, this means that there is no
+ corresponding JOIN_TAB.
+ */
+ uint join_tab_idx;
+
+ static void *operator new(size_t size);
+
+public:
+ static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
+ { return alloc_root(mem_root, size); }
+ static void operator delete(void *ptr,size_t size) { TRASH_FREE(ptr, size); }
+ static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
+
+ enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM,
+ WINDOW_FUNC_ITEM,
+ /*
+ NOT NULL literal-alike constants, which do not change their
+ value during an SQL statement execution, but can optionally
+ change their value between statements:
+ - Item_literal - real NOT NULL constants
+ - Item_param - can change between statements
+ - Item_splocal - can change between statements
+ - Item_user_var_as_out_param - hack
+ Note, Item_user_var_as_out_param actually abuses the type code.
+ It should be moved out of the Item tree eventually.
+ */
+ CONST_ITEM,
+ NULL_ITEM, // Item_null or Item_param bound to NULL
+ COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
+ CONTEXTUALLY_TYPED_VALUE_ITEM,
+ PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
+ FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
+ SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER,
+ PARAM_ITEM, TRIGGER_FIELD_ITEM,
+ EXPR_CACHE_ITEM};
+
+ enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
+
+ enum traverse_order { POSTFIX, PREFIX };
+
+ /* Cache of the result of is_expensive(). */
+ int8 is_expensive_cache;
+
+ /* Reuse size, only used by SP local variable assignment, otherwise 0 */
+ uint rsize;
+
+protected:
+ /*
+ str_values's main purpose is to be used to cache the value in
+ save_in_field
+ */
+ String str_value;
+
+ SEL_TREE *get_mm_tree_for_const(RANGE_OPT_PARAM *param);
+
+ /**
+ Create a field based on the exact data type handler.
+ */
+ Field *create_table_field_from_handler(MEM_ROOT *root, TABLE *table)
+ {
+ const Type_handler *h= type_handler();
+ return h->make_and_init_table_field(root, &name,
+ Record_addr(maybe_null),
+ *this, table);
+ }
+ /**
+ Create a field based on field_type of argument.
+ This is used to create a field for
+ - IFNULL(x,something)
+ - time functions
+ - prepared statement placeholders
+ - SP variables with data type references: DECLARE a TYPE OF t1.a;
+ @retval NULL error
+ @retval !NULL on success
+ */
+ Field *tmp_table_field_from_field_type(MEM_ROOT *root, TABLE *table)
+ {
+ DBUG_ASSERT(is_fixed());
+ const Type_handler *h= type_handler()->type_handler_for_tmp_table(this);
+ return h->make_and_init_table_field(root, &name,
+ Record_addr(maybe_null),
+ *this, table);
+ }
+ /**
+ Create a temporary field for a simple Item, which does not
+ need any special action after the field creation:
+ - is not an Item_field descendant (and not a reference to Item_field)
+ - is not an Item_result_field descendant
+ - does not need to copy any DEFAULT value to the result Field
+ - does not need to set Field::is_created_from_null_item for the result
+ See create_tmp_field_ex() for details on parameters and return values.
+ */
+ Field *create_tmp_field_ex_simple(MEM_ROOT *root,
+ TABLE *table,
+ Tmp_field_src *src,
+ const Tmp_field_param *param)
+ {
+ DBUG_ASSERT(!param->make_copy_field());
+ DBUG_ASSERT(!is_result_field());
+ DBUG_ASSERT(type() != NULL_ITEM);
+ return tmp_table_field_from_field_type(root, table);
+ }
+ Field *create_tmp_field_int(MEM_ROOT *root, TABLE *table,
+ uint convert_int_length);
+ Field *tmp_table_field_from_field_type_maybe_null(MEM_ROOT *root,
+ TABLE *table,
+ Tmp_field_src *src,
+ const Tmp_field_param *param,
+ bool is_explicit_null);
+
+ void raise_error_not_evaluable();
+ void push_note_converted_to_negative_complement(THD *thd);
+ void push_note_converted_to_positive_complement(THD *thd);
+
+ /* Helper methods, to get an Item value from another Item */
+ double val_real_from_item(Item *item)
+ {
+ DBUG_ASSERT(is_fixed());
+ double value= item->val_real();
+ null_value= item->null_value;
+ return value;
+ }
+ longlong val_int_from_item(Item *item)
+ {
+ DBUG_ASSERT(is_fixed());
+ longlong value= item->val_int();
+ null_value= item->null_value;
+ return value;
+ }
+ String *val_str_from_item(Item *item, String *str)
+ {
+ DBUG_ASSERT(is_fixed());
+ String *res= item->val_str(str);
+ if (res)
+ res->set_charset(collation.collation);
+ if ((null_value= item->null_value))
+ res= NULL;
+ return res;
+ }
+ bool val_native_from_item(THD *thd, Item *item, Native *to)
+ {
+ DBUG_ASSERT(is_fixed());
+ null_value= item->val_native(thd, to);
+ DBUG_ASSERT(null_value == item->null_value);
+ return null_value;
+ }
+ bool val_native_from_field(Field *field, Native *to)
+ {
+ if ((null_value= field->is_null()))
+ return true;
+ return (null_value= field->val_native(to));
+ }
+ bool val_native_with_conversion_from_item(THD *thd, Item *item, Native *to,
+ const Type_handler *handler)
+ {
+ DBUG_ASSERT(is_fixed());
+ return null_value= item->val_native_with_conversion(thd, to, handler);
+ }
+ my_decimal *val_decimal_from_item(Item *item, my_decimal *decimal_value)
+ {
+ DBUG_ASSERT(is_fixed());
+ my_decimal *value= item->val_decimal(decimal_value);
+ if ((null_value= item->null_value))
+ value= NULL;
+ return value;
+ }
+ bool get_date_from_item(THD *thd, Item *item,
+ MYSQL_TIME *ltime, date_mode_t fuzzydate)
+ {
+ bool rc= item->get_date(thd, ltime, fuzzydate);
+ null_value= MY_TEST(rc || item->null_value);
+ return rc;
+ }
+public:
+
+ /*
+ Cache val_str() into the own buffer, e.g. to evaluate constant
+ expressions with subqueries in the ORDER/GROUP clauses.
+ */
+ String *val_str() { return val_str(&str_value); }
+ virtual Item_func *get_item_func() { return NULL; }
+
+ const MY_LOCALE *locale_from_val_str();
+
+ LEX_CSTRING name; /* Name of item */
+ /* Original item name (if it was renamed)*/
+ const char *orig_name;
+ /**
+ Intrusive list pointer for free list. If not null, points to the next
+ Item on some Query_arena's free list. For instance, stored procedures
+ have their own Query_arena's.
+
+ @see Query_arena::free_list
+ */
+ Item *next;
+ int marker;
+ bool maybe_null; /* If item may be null */
+ bool in_rollup; /* If used in GROUP BY list
+ of a query with ROLLUP */
+ bool null_value; /* if item is null */
+ bool with_param; /* True if contains an SP parameter */
+ bool with_window_func; /* True if item contains a window func */
+ /**
+ True if any item except Item_sum contains a field. Set during parsing.
+ */
+ bool with_field;
+ uint8 common_flags;
+ bool is_autogenerated_name()
+ { return (common_flags & IS_AUTO_GENERATED_NAME); }
+ // alloc & destruct is done as start of select on THD::mem_root
+ Item(THD *thd);
+ /*
+ Constructor used by Item_field, Item_ref & aggregate (sum) functions.
+ Used for duplicating lists in processing queries with temporary
+ tables
+ Also it used for Item_cond_and/Item_cond_or for creating
+ top AND/OR structure of WHERE clause to protect it of
+ optimisation changes in prepared statements
+ */
+ Item(THD *thd, Item *item);
+ virtual ~Item()
+ {
+#ifdef EXTRA_DEBUG
+ name.str= 0;
+ name.length= 0;
+#endif
+ } /*lint -e1509 */
+ void set_name(THD *thd, const char *str, size_t length, CHARSET_INFO *cs);
+ void set_name(THD *thd, String *str)
+ {
+ set_name(thd, str->ptr(), str->length(), str->charset());
+ }
+ void set_name(THD *thd, const LEX_CSTRING &str,
+ CHARSET_INFO *cs= system_charset_info)
+ {
+ set_name(thd, str.str, str.length, cs);
+ }
+ void set_name_no_truncate(THD *thd, const char *str, uint length,
+ CHARSET_INFO *cs);
+ void init_make_send_field(Send_field *tmp_field, const Type_handler *h);
+ void share_name_with(const Item *item)
+ {
+ name= item->name;
+ common_flags= static_cast<uint8>
+ ((common_flags & ~IS_AUTO_GENERATED_NAME) |
+ (item->common_flags & IS_AUTO_GENERATED_NAME));
+ }
+ virtual void cleanup();
+ virtual void make_send_field(THD *thd, Send_field *field);
+
+ bool fix_fields_if_needed(THD *thd, Item **ref)
+ {
+ return is_fixed() ? false : fix_fields(thd, ref);
+ }
+ bool fix_fields_if_needed_for_scalar(THD *thd, Item **ref)
+ {
+ return fix_fields_if_needed(thd, ref) || check_cols(1);
+ }
+ bool fix_fields_if_needed_for_bool(THD *thd, Item **ref)
+ {
+ return fix_fields_if_needed_for_scalar(thd, ref);
+ }
+ bool fix_fields_if_needed_for_order_by(THD *thd, Item **ref)
+ {
+ return fix_fields_if_needed_for_scalar(thd, ref);
+ }
+ /*
+ By default we assume that an Item is fixed by the contstructor.
+ */
+ virtual bool fix_fields(THD *, Item **)
+ {
+ /*
+ This should not normally be called, because usually before
+ fix_fields() we check is_fixed() to be false.
+ But historically we allow fix_fields() to be called for Items
+ who return basic_const_item()==true.
+ */
+ DBUG_ASSERT(is_fixed());
+ DBUG_ASSERT(basic_const_item());
+ return false;
+ }
+ virtual bool is_fixed() const { return true; }
+ virtual void unfix_fields()
+ {
+ DBUG_ASSERT(0);
+ }
+
+ /*
+ Fix after some tables has been pulled out. Basically re-calculate all
+ attributes that are dependent on the tables.
+ */
+ virtual void fix_after_pullout(st_select_lex *new_parent, Item **ref,
+ bool merge)
+ {};
+
+ /*
+ This method should be used in case where we are sure that we do not need
+ complete fix_fields() procedure.
+ Usually this method is used by the optimizer when it has to create a new
+ item out of other already fixed items. For example, if the optimizer has
+ to create a new Item_func for an inferred equality whose left and right
+ parts are already fixed items. In some cases the optimizer cannot use
+ directly fixed items as the arguments of the created functional item,
+ but rather uses intermediate type conversion items. Then the method is
+ supposed to be applied recursively.
+ */
+ virtual void quick_fix_field()
+ {
+ DBUG_ASSERT(0);
+ }
+
+ bool save_in_value(THD *thd, struct st_value *value)
+ {
+ return type_handler()->Item_save_in_value(thd, this, value);
+ }
+
+ /* Function returns 1 on overflow and -1 on fatal errors */
+ int save_in_field_no_warnings(Field *field, bool no_conversions);
+ virtual int save_in_field(Field *field, bool no_conversions);
+ virtual bool save_in_param(THD *thd, Item_param *param);
+ virtual void save_org_in_field(Field *field,
+ fast_field_copier data
+ __attribute__ ((__unused__)))
+ { (void) save_in_field(field, 1); }
+ virtual fast_field_copier setup_fast_field_copier(Field *field)
+ { return NULL; }
+ virtual int save_safe_in_field(Field *field)
+ { return save_in_field(field, 1); }
+ virtual bool send(Protocol *protocol, st_value *buffer)
+ {
+ return type_handler()->Item_send(this, protocol, buffer);
+ }
+ virtual bool eq(const Item *, bool binary_cmp) const;
+ enum_field_types field_type() const
+ {
+ return type_handler()->field_type();
+ }
+ virtual const Type_handler *type_handler() const= 0;
+ /**
+ Detects if an Item has a fixed data type which is known
+ even before fix_fields().
+ Currently it's important only to find Items with a fixed boolean
+ data type. More item types can be marked in the future as having
+ a fixed data type (e.g. all literals, all fixed type functions, etc).
+
+ @retval NULL if the Item type is not known before fix_fields()
+ @retval the pointer to the data type handler, if the data type
+ is known before fix_fields().
+ */
+ virtual const Type_handler *fixed_type_handler() const
+ {
+ return NULL;
+ }
+ const Type_handler *type_handler_for_comparison() const
+ {
+ return type_handler()->type_handler_for_comparison();
+ }
+ virtual const Type_handler *real_type_handler() const
+ {
+ return type_handler();
+ }
+ const Type_handler *cast_to_int_type_handler() const
+ {
+ return real_type_handler()->cast_to_int_type_handler();
+ }
+ /* result_type() of an item specifies how the value should be returned */
+ Item_result result_type() const
+ {
+ return type_handler()->result_type();
+ }
+ /* ... while cmp_type() specifies how it should be compared */
+ Item_result cmp_type() const
+ {
+ return type_handler()->cmp_type();
+ }
+ const Type_handler *string_type_handler() const
+ {
+ return Type_handler::string_type_handler(max_length);
+ }
+ /*
+ Calculate the maximum length of an expression.
+ This method is used in data type aggregation for UNION, e.g.:
+ SELECT 'b' UNION SELECT COALESCE(double_10_3_field) FROM t1;
+
+ The result is usually equal to max_length, except for some numeric types.
+ In case of the INT, FLOAT, DOUBLE data types Item::max_length and
+ Item::decimals are ignored, so the returned value depends only on the
+ data type itself. E.g. for an expression of the DOUBLE(10,3) data type,
+ the result is always 53 (length 10 and precision 3 do not matter).
+
+ max_length is ignored for these numeric data types because the length limit
+ means only "expected maximum length", it is not a hard limit, so it does
+ not impose any data truncation. E.g. a column of the type INT(4) can
+ normally store big values up to 2147483647 without truncation. When we're
+ aggregating such column for UNION it's important to create a long enough
+ result column, not to lose any data.
+
+ For detailed behaviour of various data types see implementations of
+ the corresponding Type_handler_xxx::max_display_length().
+
+ Note, Item_field::max_display_length() overrides this to get
+ max_display_length() from the underlying field.
+ */
+ virtual uint32 max_display_length() const
+ {
+ return type_handler()->max_display_length(this);
+ }
+ const TYPELIB *get_typelib() const { return NULL; }
+ void set_maybe_null(bool maybe_null_arg) { maybe_null= maybe_null_arg; }
+ void set_typelib(const TYPELIB *typelib)
+ {
+ // Non-field Items (e.g. hybrid functions) never have ENUM/SET types yet.
+ DBUG_ASSERT(0);
+ }
+ Item_cache* get_cache(THD *thd) const
+ {
+ return type_handler()->Item_get_cache(thd, this);
+ }
+ virtual enum Type type() const =0;
+ bool is_of_type(Type t, Item_result cmp) const
+ {
+ return type() == t && cmp_type() == cmp;
+ }
+ /*
+ real_type() is the type of base item. This is same as type() for
+ most items, except Item_ref() and Item_cache_wrapper() where it
+ shows the type for the underlying item.
+ */
+ virtual enum Type real_type() const { return type(); }
+
+ /*
+ Return information about function monotonicity. See comment for
+ enum_monotonicity_info for details. This function can only be called
+ after fix_fields() call.
+ */
+ virtual enum_monotonicity_info get_monotonicity_info() const
+ { return NON_MONOTONIC; }
+
+ /*
+ Convert "func_arg $CMP$ const" half-interval into "FUNC(func_arg) $CMP2$ const2"
+
+ SYNOPSIS
+ val_int_endpoint()
+ left_endp FALSE <=> The interval is "x < const" or "x <= const"
+ TRUE <=> The interval is "x > const" or "x >= const"
+
+ incl_endp IN FALSE <=> the comparison is '<' or '>'
+ TRUE <=> the comparison is '<=' or '>='
+ OUT The same but for the "F(x) $CMP$ F(const)" comparison
+
+ DESCRIPTION
+ This function is defined only for unary monotonic functions. The caller
+ supplies the source half-interval
+
+ x $CMP$ const
+
+ The value of const is supplied implicitly as the value this item's
+ argument, the form of $CMP$ comparison is specified through the
+ function's arguments. The calle returns the result interval
+
+ F(x) $CMP2$ F(const)
+
+ passing back F(const) as the return value, and the form of $CMP2$
+ through the out parameter. NULL values are assumed to be comparable and
+ be less than any non-NULL values.
+
+ RETURN
+ The output range bound, which equal to the value of val_int()
+ - If the value of the function is NULL then the bound is the
+ smallest possible value of LONGLONG_MIN
+ */
+ virtual longlong val_int_endpoint(bool left_endp, bool *incl_endp)
+ { DBUG_ASSERT(0); return 0; }
+
+
+ /* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */
+ /*
+ Return double precision floating point representation of item.
+
+ SYNOPSIS
+ val_real()
+
+ RETURN
+ In case of NULL value return 0.0 and set null_value flag to TRUE.
+ If value is not null null_value flag will be reset to FALSE.
+ */
+ virtual double val_real()=0;
+ Double_null to_double_null()
+ {
+ // val_real() must be caleed on a separate line. See to_longlong_null()
+ double nr= val_real();
+ return Double_null(nr, null_value);
+ }
+ /*
+ Return integer representation of item.
+
+ SYNOPSIS
+ val_int()
+
+ RETURN
+ In case of NULL value return 0 and set null_value flag to TRUE.
+ If value is not null null_value flag will be reset to FALSE.
+ */
+ virtual longlong val_int()=0;
+ Longlong_hybrid to_longlong_hybrid()
+ {
+ return Longlong_hybrid(val_int(), unsigned_flag);
+ }
+ Longlong_null to_longlong_null()
+ {
+ longlong nr= val_int();
+ /*
+ C++ does not guarantee the order of parameter evaluation,
+ so to make sure "null_value" is passed to the constructor
+ after the val_int() call, val_int() is caled on a separate line.
+ */
+ return Longlong_null(nr, null_value);
+ }
+ Longlong_hybrid_null to_longlong_hybrid_null()
+ {
+ return Longlong_hybrid_null(to_longlong_null(), unsigned_flag);
+ }
+ /**
+ Get a value for CAST(x AS SIGNED).
+ Too large positive unsigned integer values are converted
+ to negative complements.
+ Values of non-integer data types are adjusted to the SIGNED range.
+ */
+ virtual longlong val_int_signed_typecast()
+ {
+ return cast_to_int_type_handler()->Item_val_int_signed_typecast(this);
+ }
+ longlong val_int_signed_typecast_from_str();
+ /**
+ Get a value for CAST(x AS UNSIGNED).
+ Negative signed integer values are converted
+ to positive complements.
+ Values of non-integer data types are adjusted to the UNSIGNED range.
+ */
+ virtual longlong val_int_unsigned_typecast()
+ {
+ return cast_to_int_type_handler()->Item_val_int_unsigned_typecast(this);
+ }
+ longlong val_int_unsigned_typecast_from_int();
+ longlong val_int_unsigned_typecast_from_str();
+ longlong val_int_unsigned_typecast_from_real();
+
+ /**
+ Get a value for CAST(x AS UNSIGNED).
+ Huge positive unsigned values are converted to negative complements.
+ */
+ longlong val_int_signed_typecast_from_int();
+ longlong val_int_signed_typecast_from_real();
+
+ /*
+ This is just a shortcut to avoid the cast. You should still use
+ unsigned_flag to check the sign of the item.
+ */
+ inline ulonglong val_uint() { return (ulonglong) val_int(); }
+
+ /*
+ Return string representation of this item object.
+
+ SYNOPSIS
+ val_str()
+ str an allocated buffer this or any nested Item object can use to
+ store return value of this method.
+
+ NOTE
+ The caller can modify the returned String, if it's not marked
+ "const" (with the String::mark_as_const() method). That means that
+ if the item returns its own internal buffer (e.g. tmp_value), it
+ *must* be marked "const" [1]. So normally it's preferable to
+ return the result value in the String, that was passed as an
+ argument. But, for example, SUBSTR() returns a String that simply
+ points into the buffer of SUBSTR()'s args[0]->val_str(). Such a
+ String is always "const", so it's ok to use tmp_value for that and
+ avoid reallocating/copying of the argument String.
+
+ [1] consider SELECT CONCAT(f, ":", f) FROM (SELECT func() AS f);
+ here the return value of f() is used twice in the top-level
+ select, and if they share the same tmp_value buffer, modifying the
+ first one will implicitly modify the second too.
+
+ RETURN
+ In case of NULL value return 0 (NULL pointer) and set null_value flag
+ to TRUE.
+ If value is not null null_value flag will be reset to FALSE.
+ */
+ virtual String *val_str(String *str)=0;
+
+
+ bool val_native_with_conversion(THD *thd, Native *to, const Type_handler *th)
+ {
+ return th->Item_val_native_with_conversion(thd, this, to);
+ }
+ bool val_native_with_conversion_result(THD *thd, Native *to,
+ const Type_handler *th)
+ {
+ return th->Item_val_native_with_conversion_result(thd, this, to);
+ }
+
+ virtual bool val_native(THD *thd, Native *to)
+ {
+ /*
+ The default implementation for the Items that do not need native format:
+ - Item_basic_value (default implementation)
+ - Item_copy
+ - Item_exists_subselect
+ - Item_sum_field
+ - Item_sum_or_func (default implementation)
+ - Item_proc
+ - Item_type_holder (as val_xxx() are never called for it);
+
+ These hybrid Item types override val_native():
+ - Item_field
+ - Item_param
+ - Item_sp_variable
+ - Item_ref
+ - Item_cache_wrapper
+ - Item_direct_ref
+ - Item_direct_view_ref
+ - Item_ref_null_helper
+ - Item_name_const
+ - Item_time_literal
+ - Item_sum_or_func
+ Note, these hybrid type Item_sum_or_func descendants
+ override the default implementation:
+ * Item_sum_hybrid
+ * Item_func_hybrid_field_type
+ * Item_func_min_max
+ * Item_func_sp
+ * Item_func_last_value
+ * Item_func_rollup_const
+ */
+ DBUG_ASSERT(0);
+ return null_value= true;
+ }
+ virtual bool val_native_result(THD *thd, Native *to)
+ {
+ return val_native(thd, to);
+ }
+
+ /*
+ Returns string representation of this item in ASCII format.
+
+ SYNOPSIS
+ val_str_ascii()
+ str - similar to val_str();
+
+ NOTE
+ This method is introduced for performance optimization purposes.
+
+ 1. val_str() result of some Items in string context
+ depends on @@character_set_results.
+ @@character_set_results can be set to a "real multibyte" character
+ set like UCS2, UTF16, UTF32. (We'll use only UTF32 in the examples
+ below for convenience.)
+
+ So the default string result of such functions
+ in these circumstances is real multi-byte character set, like UTF32.
+
+ For example, all numbers in string context
+ return result in @@character_set_results:
+
+ SELECT CONCAT(20010101); -> UTF32
+
+ We do sprintf() first (to get ASCII representation)
+ and then convert to UTF32;
+
+ So these kind "data sources" can use ASCII representation
+ internally, but return multi-byte data only because
+ @@character_set_results wants so.
+ Therefore, conversion from ASCII to UTF32 is applied internally.
+
+
+ 2. Some other functions need in fact ASCII input.
+
+ For example,
+ inet_aton(), GeometryFromText(), Convert_TZ(), GET_FORMAT().
+
+ Similar, fields of certain type, like DATE, TIME,
+ when you insert string data into them, expect in fact ASCII input.
+ If they get non-ASCII input, for example UTF32, they
+ convert input from UTF32 to ASCII, and then use ASCII
+ representation to do further processing.
+
+
+ 3. Now imagine we pass result of a data source of the first type
+ to a data destination of the second type.
+
+ What happens:
+ a. data source converts data from ASCII to UTF32, because
+ @@character_set_results wants so and passes the result to
+ data destination.
+ b. data destination gets UTF32 string.
+ c. data destination converts UTF32 string to ASCII,
+ because it needs ASCII representation to be able to handle data
+ correctly.
+
+ As a result we get two steps of unnecessary conversion:
+ From ASCII to UTF32, then from UTF32 to ASCII.
+
+ A better way to handle these situations is to pass ASCII
+ representation directly from the source to the destination.
+
+ This is why val_str_ascii() introduced.
+
+ RETURN
+ Similar to val_str()
+ */
+ virtual String *val_str_ascii(String *str);
+
+ /*
+ Returns the result of val_str_ascii(), translating NULLs back
+ to empty strings (if MODE_EMPTY_STRING_IS_NULL is set).
+ */
+ String *val_str_ascii_revert_empty_string_is_null(THD *thd, String *str);
+
+ /*
+ Returns the val_str() value converted to the given character set.
+ */
+ String *val_str(String *str, String *converter, CHARSET_INFO *to);
+
+ virtual String *val_json(String *str) { return val_str(str); }
+ /*
+ Return decimal representation of item with fixed point.
+
+ SYNOPSIS
+ val_decimal()
+ decimal_buffer buffer which can be used by Item for returning value
+ (but can be not)
+
+ NOTE
+ Returned value should not be changed if it is not the same which was
+ passed via argument.
+
+ RETURN
+ Return pointer on my_decimal (it can be other then passed via argument)
+ if value is not NULL (null_value flag will be reset to FALSE).
+ In case of NULL value it return 0 pointer and set null_value flag
+ to TRUE.
+ */
+ virtual my_decimal *val_decimal(my_decimal *decimal_buffer)= 0;
+ /*
+ Return boolean value of item.
+
+ RETURN
+ FALSE value is false or NULL
+ TRUE value is true (not equal to 0)
+ */
+ virtual bool val_bool()
+ {
+ return type_handler()->Item_val_bool(this);
+ }
+
+ bool eval_const_cond()
+ {
+ DBUG_ASSERT(const_item());
+ DBUG_ASSERT(!is_expensive());
+ return val_bool();
+ }
+
+ /*
+ save_val() is method of val_* family which stores value in the given
+ field.
+ */
+ virtual void save_val(Field *to) { save_org_in_field(to, NULL); }
+ /*
+ save_result() is method of val*result() family which stores value in
+ the given field.
+ */
+ virtual void save_result(Field *to) { save_val(to); }
+ /* Helper functions, see item_sum.cc */
+ String *val_string_from_real(String *str);
+ String *val_string_from_int(String *str);
+ my_decimal *val_decimal_from_real(my_decimal *decimal_value);
+ my_decimal *val_decimal_from_int(my_decimal *decimal_value);
+ my_decimal *val_decimal_from_string(my_decimal *decimal_value);
+ longlong val_int_from_real()
+ {
+ DBUG_ASSERT(is_fixed());
+ return Converter_double_to_longlong_with_warn(val_real(), false).result();
+ }
+ longlong val_int_from_str(int *error);
+
+ /*
+ Returns true if this item can be calculated during
+ value_depends_on_sql_mode()
+ */
+ bool value_depends_on_sql_mode_const_item()
+ {
+ /*
+ Currently we use value_depends_on_sql_mode() only for virtual
+ column expressions. They should not contain any expensive items.
+ If we ever get a crash on the assert below, it means
+ check_vcol_func_processor() is badly implemented for this item.
+ */
+ DBUG_ASSERT(!is_expensive());
+ /*
+ It should return const_item() actually.
+ But for some reasons Item_field::const_item() returns true
+ at value_depends_on_sql_mode() call time.
+ This should be checked and fixed.
+ */
+ return basic_const_item();
+ }
+ virtual Sql_mode_dependency value_depends_on_sql_mode() const
+ {
+ return Sql_mode_dependency();
+ }
+
+ int save_time_in_field(Field *field, bool no_conversions);
+ int save_date_in_field(Field *field, bool no_conversions);
+ int save_str_in_field(Field *field, bool no_conversions);
+ int save_real_in_field(Field *field, bool no_conversions);
+ int save_int_in_field(Field *field, bool no_conversions);
+ int save_decimal_in_field(Field *field, bool no_conversions);
+
+ int save_str_value_in_field(Field *field, String *result);
+
+ virtual Field *get_tmp_table_field() { return 0; }
+ virtual Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table);
+ virtual const char *full_name() const { return name.str ? name.str : "???"; }
+ const char *field_name_or_null()
+ { return real_item()->type() == Item::FIELD_ITEM ? name.str : NULL; }
+ const TABLE_SHARE *field_table_or_null();
+
+ /*
+ *result* family of methods is analog of *val* family (see above) but
+ return value of result_field of item if it is present. If Item have not
+ result field, it return val(). This methods set null_value flag in same
+ way as *val* methods do it.
+ */
+ virtual double val_result() { return val_real(); }
+ virtual longlong val_int_result() { return val_int(); }
+ virtual String *str_result(String* tmp) { return val_str(tmp); }
+ virtual my_decimal *val_decimal_result(my_decimal *val)
+ { return val_decimal(val); }
+ virtual bool val_bool_result() { return val_bool(); }
+ virtual bool is_null_result() { return is_null(); }
+ /*
+ Returns 1 if result type and collation for val_str() can change between
+ calls
+ */
+ virtual bool dynamic_result() { return 0; }
+ /*
+ Bitmap of tables used by item
+ (note: if you need to check dependencies on individual columns, check out
+ class Field_enumerator)
+ */
+ virtual table_map used_tables() const { return (table_map) 0L; }
+ virtual table_map all_used_tables() const { return used_tables(); }
+ /*
+ Return table map of tables that can't be NULL tables (tables that are
+ used in a context where if they would contain a NULL row generated
+ by a LEFT or RIGHT join, the item would not be true).
+ This expression is used on WHERE item to determinate if a LEFT JOIN can be
+ converted to a normal join.
+ Generally this function should return used_tables() if the function
+ would return null if any of the arguments are null
+ As this is only used in the beginning of optimization, the value don't
+ have to be updated in update_used_tables()
+ */
+ virtual table_map not_null_tables() const { return used_tables(); }
+ /*
+ Returns true if this is a simple constant item like an integer, not
+ a constant expression. Used in the optimizer to propagate basic constants.
+ */
+ virtual bool basic_const_item() const { return 0; }
+ /**
+ Determines if the expression is allowed as
+ a virtual column assignment source:
+ INSERT INTO t1 (vcol) VALUES (10) -> error
+ INSERT INTO t1 (vcol) VALUES (NULL) -> ok
+ */
+ virtual bool vcol_assignment_allowed_value() const { return false; }
+ /**
+ Test if "this" is an ORDER position (rather than an expression).
+ Notes:
+ - can be called before fix_fields().
+ - local SP variables (even of integer types) are always expressions, not
+ positions. (And they can't be used before fix_fields is called for them).
+ */
+ virtual bool is_order_clause_position() const { return false; }
+ /*
+ Determines if the Item is an evaluable expression, that is
+ it can return a value, so we can call methods val_xxx(), get_date(), etc.
+ Most items are evaluable expressions.
+ Examples of non-evaluable expressions:
+ - Item_contextually_typed_value_specification (handling DEFAULT and IGNORE)
+ - Item_type_param bound to DEFAULT and IGNORE
+ We cannot call the mentioned methods for these Items,
+ their method implementations typically have DBUG_ASSERT(0).
+ */
+ virtual bool is_evaluable_expression() const { return true; }
+ bool check_is_evaluable_expression_or_error()
+ {
+ if (is_evaluable_expression())
+ return false; // Ok
+ raise_error_not_evaluable();
+ return true; // Error
+ }
+ /* cloning of constant items (0 if it is not const) */
+ virtual Item *clone_item(THD *thd) { return 0; }
+ /* deep copy item */
+ virtual Item* build_clone(THD *thd) { return get_copy(thd); }
+ virtual cond_result eq_cmp_result() const { return COND_OK; }
+ inline uint float_length(uint decimals_par) const
+ { return decimals < FLOATING_POINT_DECIMALS ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;}
+ /* Returns total number of decimal digits */
+ virtual uint decimal_precision() const
+ {
+ return type_handler()->Item_decimal_precision(this);
+ }
+ /* Returns the number of integer part digits only */
+ inline int decimal_int_part() const
+ { return my_decimal_int_part(decimal_precision(), decimals); }
+ /*
+ Returns the number of fractional digits only.
+ NOT_FIXED_DEC is replaced to the maximum possible number
+ of fractional digits, taking into account the data type.
+ */
+ uint decimal_scale() const
+ {
+ return type_handler()->Item_decimal_scale(this);
+ }
+ /*
+ Returns how many digits a divisor adds into a division result.
+ This is important when the integer part of the divisor can be 0.
+ In this example:
+ SELECT 1 / 0.000001; -> 1000000.0000
+ the divisor adds 5 digits into the result precision.
+
+ Currently this method only replaces NOT_FIXED_DEC to
+ TIME_SECOND_PART_DIGITS for temporal data types.
+ This method can be made virtual, to create more efficient (smaller)
+ data types for division results.
+ For example, in
+ SELECT 1/1.000001;
+ the divisor could provide no additional precision into the result,
+ so could any other items that are know to return a result
+ with non-zero integer part.
+ */
+ uint divisor_precision_increment() const
+ {
+ return type_handler()->Item_divisor_precision_increment(this);
+ }
+ /**
+ TIME or DATETIME precision of the item: 0..6
+ */
+ uint time_precision(THD *thd)
+ {
+ return const_item() ? type_handler()->Item_time_precision(thd, this) :
+ MY_MIN(decimals, TIME_SECOND_PART_DIGITS);
+ }
+ uint datetime_precision(THD *thd)
+ {
+ return const_item() ? type_handler()->Item_datetime_precision(thd, this) :
+ MY_MIN(decimals, TIME_SECOND_PART_DIGITS);
+ }
+ virtual longlong val_int_min() const
+ {
+ return LONGLONG_MIN;
+ }
+ /*
+ Returns true if this is constant (during query execution, i.e. its value
+ will not change until next fix_fields) and its value is known.
+ */
+ virtual bool const_item() const { return used_tables() == 0; }
+ /*
+ Returns true if this is constant but its value may be not known yet.
+ (Can be used for parameters of prep. stmts or of stored procedures.)
+ */
+ virtual bool const_during_execution() const
+ { return (used_tables() & ~PARAM_TABLE_BIT) == 0; }
+
+ /**
+ This method is used for to:
+ - to generate a view definition query (SELECT-statement);
+ - to generate a SQL-query for EXPLAIN EXTENDED;
+ - to generate a SQL-query to be shown in INFORMATION_SCHEMA;
+ - debug.
+
+ For more information about view definition query, INFORMATION_SCHEMA
+ query and why they should be generated from the Item-tree, @see
+ mysql_register_view().
+ */
+ virtual enum precedence precedence() const { return DEFAULT_PRECEDENCE; }
+ enum precedence higher_precedence() const
+ { return (enum precedence)(precedence() + 1); }
+ void print_parenthesised(String *str, enum_query_type query_type,
+ enum precedence parent_prec);
+ /**
+ This helper is used to print expressions as a part of a table definition,
+ in particular for
+ - generated columns
+ - check constraints
+ - default value expressions
+ - partitioning expressions
+ */
+ void print_for_table_def(String *str)
+ {
+ print_parenthesised(str,
+ (enum_query_type)(QT_ITEM_ORIGINAL_FUNC_NULLIF |
+ QT_ITEM_IDENT_SKIP_DB_NAMES |
+ QT_ITEM_IDENT_SKIP_TABLE_NAMES |
+ QT_NO_DATA_EXPANSION |
+ QT_TO_SYSTEM_CHARSET),
+ LOWEST_PRECEDENCE);
+ }
+ virtual void print(String *str, enum_query_type query_type);
+
+ class Print: public String
+ {
+ public:
+ Print(Item *item, enum_query_type type)
+ {
+ item->print(this, type);
+ }
+ };
+
+ void print_item_w_name(String *str, enum_query_type query_type);
+ void print_value(String *str);
+
+ virtual void update_used_tables() {}
+ virtual COND *build_equal_items(THD *thd, COND_EQUAL *inheited,
+ bool link_item_fields,
+ COND_EQUAL **cond_equal_ref)
+ {
+ update_used_tables();
+ DBUG_ASSERT(!cond_equal_ref || !cond_equal_ref[0]);
+ return this;
+ }
+ virtual COND *remove_eq_conds(THD *thd, Item::cond_result *cond_value,
+ bool top_level);
+ virtual void add_key_fields(JOIN *join, KEY_FIELD **key_fields,
+ uint *and_level,
+ table_map usable_tables,
+ SARGABLE_PARAM **sargables)
+ {
+ return;
+ }
+ /*
+ Make a select tree for all keys in a condition or a condition part
+ @param param Context
+ @param cond_ptr[OUT] Store a replacement item here if the condition
+ can be simplified, e.g.:
+ WHERE part1 OR part2 OR part3
+ with one of the partN evaluating to SEL_TREE::ALWAYS.
+ */
+ virtual SEL_TREE *get_mm_tree(RANGE_OPT_PARAM *param, Item **cond_ptr);
+ /*
+ Checks whether the item is:
+ - a simple equality (field=field_item or field=constant_item), or
+ - a row equality
+ and form multiple equality predicates.
+ */
+ virtual bool check_equality(THD *thd, COND_EQUAL *cond, List<Item> *eq_list)
+ {
+ return false;
+ }
+ virtual void split_sum_func(THD *thd, Ref_ptr_array ref_pointer_array,
+ List<Item> &fields, uint flags) {}
+ /* Called for items that really have to be split */
+ void split_sum_func2(THD *thd, Ref_ptr_array ref_pointer_array,
+ List<Item> &fields,
+ Item **ref, uint flags);
+ virtual bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)= 0;
+ bool get_date_from_int(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+ bool get_date_from_real(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+ bool get_date_from_string(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+ bool get_time(THD *thd, MYSQL_TIME *ltime)
+ { return get_date(thd, ltime, Time::Options(thd)); }
+ // Get a DATE or DATETIME value in numeric packed format for comparison
+ virtual longlong val_datetime_packed(THD *thd)
+ {
+ return Datetime(thd, this, Datetime::Options_cmp(thd)).to_packed();
+ }
+ // Get a TIME value in numeric packed format for comparison
+ virtual longlong val_time_packed(THD *thd)
+ {
+ return Time(thd, this, Time::Options_cmp(thd)).to_packed();
+ }
+ longlong val_datetime_packed_result(THD *thd);
+ longlong val_time_packed_result(THD *thd);
+
+ virtual bool get_date_result(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+ { return get_date(thd, ltime,fuzzydate); }
+
+ /*
+ The method allows to determine nullness of a complex expression
+ without fully evaluating it, instead of calling val/result*() then
+ checking null_value. Used in Item_func_isnull/Item_func_isnotnull
+ and Item_sum_count.
+ Any new item which can be NULL must implement this method.
+ */
+ virtual bool is_null() { return 0; }
+
+ /*
+ Make sure the null_value member has a correct value.
+ */
+ virtual void update_null_value ()
+ {
+ return type_handler()->Item_update_null_value(this);
+ }
+
+ /*
+ Inform the item that there will be no distinction between its result
+ being FALSE or NULL.
+
+ NOTE
+ This function will be called for eg. Items that are top-level AND-parts
+ of the WHERE clause. Items implementing this function (currently
+ Item_cond_and and subquery-related item) enable special optimizations
+ when they are "top level".
+ */
+ virtual void top_level_item() {}
+ /*
+ Return TRUE if it is item of top WHERE level (AND/OR) and it is
+ important, return FALSE if it not important (we can not use to simplify
+ calculations) or not top level
+ */
+ virtual bool is_top_level_item() const
+ { return FALSE; /* not important */}
+ /*
+ return IN/ALL/ANY subquery or NULL
+ */
+ virtual Item_in_subselect* get_IN_subquery()
+ { return NULL; /* in is not IN/ALL/ANY */ }
+ /*
+ set field of temporary table for Item which can be switched on temporary
+ table during query processing (grouping and so on)
+ */
+ virtual bool is_result_field() { return 0; }
+ virtual bool is_json_type() { return false; }
+ virtual bool is_bool_literal() const { return false; }
+ /* This is to handle printing of default values */
+ virtual bool need_parentheses_in_default() { return false; }
+ virtual void save_in_result_field(bool no_conversions) {}
+ /*
+ Data type format implied by the CHECK CONSTRAINT,
+ to be sent to the client in the result set metadata.
+ */
+ virtual bool set_format_by_check_constraint(Send_field_extended_metadata *)
+ const
+ {
+ return false;
+ }
+ /*
+ set value of aggregate function in case of no rows for grouping were found
+ */
+ virtual void no_rows_in_result() {}
+ virtual void restore_to_before_no_rows_in_result() {}
+ virtual Item *copy_or_same(THD *thd) { return this; }
+ virtual Item *copy_andor_structure(THD *thd) { return this; }
+ virtual Item *real_item() { return this; }
+ virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
+ virtual Item *make_odbc_literal(THD *thd, const LEX_CSTRING *typestr)
+ {
+ return this;
+ }
+
+ static CHARSET_INFO *default_charset();
+
+ CHARSET_INFO *charset_for_protocol(void) const
+ {
+ return type_handler()->charset_for_protocol(this);
+ };
+
+ virtual bool walk(Item_processor processor, bool walk_subquery, void *arg)
+ {
+ return (this->*processor)(arg);
+ }
+
+ virtual Item* transform(THD *thd, Item_transformer transformer, uchar *arg);
+
+ /*
+ This function performs a generic "compilation" of the Item tree.
+ The process of compilation is assumed to go as follows:
+
+ compile()
+ {
+ if (this->*some_analyzer(...))
+ {
+ compile children if any;
+ this->*some_transformer(...);
+ }
+ }
+
+ i.e. analysis is performed top-down while transformation is done
+ bottom-up.
+ */
+ virtual Item* compile(THD *thd, Item_analyzer analyzer, uchar **arg_p,
+ Item_transformer transformer, uchar *arg_t)
+ {
+ if ((this->*analyzer) (arg_p))
+ return ((this->*transformer) (thd, arg_t));
+ return 0;
+ }
+
+ virtual void traverse_cond(Cond_traverser traverser,
+ void *arg, traverse_order order)
+ {
+ (*traverser)(this, arg);
+ }
+
+ /*========= Item processors, to be used with Item::walk() ========*/
+ virtual bool remove_dependence_processor(void *arg) { return 0; }
+ virtual bool cleanup_processor(void *arg);
+ virtual bool cleanup_excluding_fields_processor (void *arg)
+ { return cleanup_processor(arg); }
+ bool cleanup_excluding_immutables_processor (void *arg);
+ virtual bool cleanup_excluding_const_fields_processor (void *arg)
+ { return cleanup_processor(arg); }
+ virtual bool collect_item_field_processor(void *arg) { return 0; }
+ virtual bool unknown_splocal_processor(void *arg) { return 0; }
+ virtual bool collect_outer_ref_processor(void *arg) {return 0; }
+ virtual bool check_inner_refs_processor(void *arg) { return 0; }
+ virtual bool find_item_in_field_list_processor(void *arg) { return 0; }
+ virtual bool find_item_processor(void *arg);
+ virtual bool change_context_processor(void *arg) { return 0; }
+ virtual bool reset_query_id_processor(void *arg) { return 0; }
+ virtual bool is_expensive_processor(void *arg) { return 0; }
+
+ // FIXME reduce the number of "add field to bitmap" processors
+ virtual bool add_field_to_set_processor(void *arg) { return 0; }
+ virtual bool register_field_in_read_map(void *arg) { return 0; }
+ virtual bool register_field_in_write_map(void *arg) { return 0; }
+ virtual bool register_field_in_bitmap(void *arg) { return 0; }
+ virtual bool update_table_bitmaps_processor(void *arg) { return 0; }
+
+ virtual bool enumerate_field_refs_processor(void *arg) { return 0; }
+ virtual bool mark_as_eliminated_processor(void *arg) { return 0; }
+ virtual bool eliminate_subselect_processor(void *arg) { return 0; }
+ virtual bool set_fake_select_as_master_processor(void *arg) { return 0; }
+ virtual bool view_used_tables_processor(void *arg) { return 0; }
+ virtual bool eval_not_null_tables(void *arg) { return 0; }
+ virtual bool is_subquery_processor(void *arg) { return 0; }
+ virtual bool count_sargable_conds(void *arg) { return 0; }
+ virtual bool limit_index_condition_pushdown_processor(void *arg) { return 0; }
+ virtual bool exists2in_processor(void *arg) { return 0; }
+ virtual bool find_selective_predicates_list_processor(void *arg) { return 0; }
+ bool cleanup_is_expensive_cache_processor(void *arg)
+ {
+ is_expensive_cache= (int8)(-1);
+ return 0;
+ }
+
+ /**
+ Check db/table_name if they defined in item and match arg values
+
+ @param arg Pointer to Check_table_name_prm structure
+
+ @retval true Match failed
+ @retval false Match succeeded
+ */
+ virtual bool check_table_name_processor(void *arg) { return false; }
+ /*
+ TRUE if the expression depends only on the table indicated by tab_map
+ or can be converted to such an exression using equalities.
+ Not to be used for AND/OR formulas.
+ */
+ virtual bool excl_dep_on_table(table_map tab_map) { return false; }
+ /*
+ TRUE if the expression depends only on grouping fields of sel
+ or can be converted to such an expression using equalities.
+ It also checks if the expression doesn't contain stored procedures,
+ subqueries or randomly generated elements.
+ Not to be used for AND/OR formulas.
+ */
+ virtual bool excl_dep_on_grouping_fields(st_select_lex *sel)
+ { return false; }
+ /*
+ TRUE if the expression depends only on fields from the left part of
+ IN subquery or can be converted to such an expression using equalities.
+ Not to be used for AND/OR formulas.
+ */
+ virtual bool excl_dep_on_in_subq_left_part(Item_in_subselect *subq_pred)
+ { return false; }
+
+ virtual bool switch_to_nullable_fields_processor(void *arg) { return 0; }
+ virtual bool find_function_processor (void *arg) { return 0; }
+ /*
+ Check if a partition function is allowed
+ SYNOPSIS
+ check_partition_func_processor()
+ int_arg Ignored
+ RETURN VALUE
+ TRUE Partition function not accepted
+ FALSE Partition function accepted
+
+ DESCRIPTION
+ check_partition_func_processor is used to check if a partition function
+ uses an allowed function. An allowed function will always ensure that
+ X=Y guarantees that also part_function(X)=part_function(Y) where X is
+ a set of partition fields and so is Y. The problems comes mainly from
+ character sets where two equal strings can be quite unequal. E.g. the
+ german character for double s is equal to 2 s.
+
+ The default is that an item is not allowed
+ in a partition function. Allowed functions
+ can never depend on server version, they cannot depend on anything
+ related to the environment. They can also only depend on a set of
+ fields in the table itself. They cannot depend on other tables and
+ cannot contain any queries and cannot contain udf's or similar.
+ If a new Item class is defined and it inherits from a class that is
+ allowed in a partition function then it is very important to consider
+ whether this should be inherited to the new class. If not the function
+ below should be defined in the new Item class.
+
+ The general behaviour is that most integer functions are allowed.
+ If the partition function contains any multi-byte collations then
+ the function check_part_func_fields will report an error on the
+ partition function independent of what functions are used. So the
+ only character sets allowed are single character collation and
+ even for those only a limited set of functions are allowed. The
+ problem with multi-byte collations is that almost every string
+ function has the ability to change things such that two strings
+ that are equal will not be equal after manipulated by a string
+ function. E.g. two strings one contains a double s, there is a
+ special german character that is equal to two s. Now assume a
+ string function removes one character at this place, then in
+ one the double s will be removed and in the other there will
+ still be one s remaining and the strings are no longer equal
+ and thus the partition function will not sort equal strings into
+ the same partitions.
+
+ So the check if a partition function is valid is two steps. First
+ check that the field types are valid, next check that the partition
+ function is valid. The current set of partition functions valid
+ assumes that there are no multi-byte collations amongst the partition
+ fields.
+ */
+ virtual bool check_partition_func_processor(void *arg) { return 1;}
+ virtual bool post_fix_fields_part_expr_processor(void *arg) { return 0; }
+ virtual bool rename_fields_processor(void *arg) { return 0; }
+ /*
+ TRUE if the function is knowingly TRUE or FALSE.
+ Not to be used for AND/OR formulas.
+ */
+ virtual bool is_simplified_cond_processor(void *arg) { return false; }
+
+ /** Processor used to check acceptability of an item in the defining
+ expression for a virtual column
+
+ @param arg always ignored
+
+ @retval 0 the item is accepted in the definition of a virtual column
+ @retval 1 otherwise
+ */
+ struct vcol_func_processor_result
+ {
+ uint errors; /* Bits of possible errors */
+ const char *name; /* Not supported function */
+ Alter_info *alter_info;
+ vcol_func_processor_result() :
+ errors(0), name(NULL), alter_info(NULL) {}
+ };
+ struct func_processor_rename
+ {
+ LEX_CSTRING db_name;
+ LEX_CSTRING table_name;
+ List<Create_field> fields;
+ };
+ virtual bool check_vcol_func_processor(void *arg)
+ {
+ return mark_unsupported_function(full_name(), arg, VCOL_IMPOSSIBLE);
+ }
+ virtual bool check_field_expression_processor(void *arg) { return 0; }
+ virtual bool check_func_default_processor(void *arg) { return 0; }
+ /*
+ Check if an expression value has allowed arguments, like DATE/DATETIME
+ for date functions. Also used by partitioning code to reject
+ timezone-dependent expressions in a (sub)partitioning function.
+ */
+ virtual bool check_valid_arguments_processor(void *arg) { return 0; }
+ virtual bool update_vcol_processor(void *arg) { return 0; }
+ virtual bool set_fields_as_dependent_processor(void *arg) { return 0; }
+ /*
+ Find if some of the key parts of table keys (the reference on table is
+ passed as an argument) participate in the expression.
+ If there is some, sets a bit for this key in the proper key map.
+ */
+ virtual bool check_index_dependence(void *arg) { return 0; }
+ /*============== End of Item processor list ======================*/
+
+ /*
+ Given a condition P from the WHERE clause or from an ON expression of
+ the processed SELECT S and a set of join tables from S marked in the
+ parameter 'allowed'={T} a call of P->find_not_null_fields({T}) has to
+ find the set fields {F} of the tables from 'allowed' such that:
+ - each field from {F} is declared as nullable
+ - each record of table t from {T} that contains NULL as the value for at
+ at least one field from {F} can be ignored when building the result set
+ for S
+ It is assumed here that the condition P is conjunctive and all its column
+ references belong to T.
+
+ Examples:
+ CREATE TABLE t1 (a int, b int);
+ CREATE TABLE t2 (a int, b int);
+
+ SELECT * FROM t1,t2 WHERE t1.a=t2.a and t1.b > 5;
+ A call of find_not_null_fields() for the whole WHERE condition and {t1,t2}
+ should find {t1.a,t1.b,t2.a}
+
+ SELECT * FROM t1 LEFT JOIN ON (t1.a=t2.a and t2.a > t2.b);
+ A call of find_not_null_fields() for the ON expression and {t2}
+ should find {t2.a,t2.b}
+
+ The function returns TRUE if it succeeds to prove that all records of
+ a table from {T} can be ignored. Otherwise it always returns FALSE.
+
+ Example:
+ SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t2.a IS NULL;
+ A call of find_not_null_fields() for the WHERE condition and {t1,t2}
+ will return TRUE.
+
+ It is assumed that the implementation of this virtual function saves
+ the info on the found set of fields in the structures associates with
+ tables from {T}.
+ */
+ virtual bool find_not_null_fields(table_map allowed) { return false; }
+
+ /*
+ Does not guarantee deep copy (depends on copy ctor).
+ See build_clone() for deep copy.
+ */
+ virtual Item *get_copy(THD *thd)=0;
+
+ bool cache_const_expr_analyzer(uchar **arg);
+ Item* cache_const_expr_transformer(THD *thd, uchar *arg);
+
+ virtual Item* propagate_equal_fields(THD*, const Context &, COND_EQUAL *)
+ {
+ return this;
+ };
+
+ Item* propagate_equal_fields_and_change_item_tree(THD *thd,
+ const Context &ctx,
+ COND_EQUAL *cond,
+ Item **place);
+
+ /* arg points to REPLACE_EQUAL_FIELD_ARG object */
+ virtual Item *replace_equal_field(THD *thd, uchar *arg) { return this; }
+
+ struct Collect_deps_prm
+ {
+ List<Item> *parameters;
+ /* unit from which we count nest_level */
+ st_select_lex_unit *nest_level_base;
+ uint count;
+ int nest_level;
+ bool collect;
+ };
+
+ struct Check_table_name_prm
+ {
+ LEX_CSTRING db;
+ LEX_CSTRING table_name;
+ String field;
+ Check_table_name_prm(LEX_CSTRING _db, LEX_CSTRING _table_name) :
+ db(_db), table_name(_table_name) {}
+ };
+
+ /*
+ For SP local variable returns pointer to Item representing its
+ current value and pointer to current Item otherwise.
+ */
+ virtual Item *this_item() { return this; }
+ virtual const Item *this_item() const { return this; }
+
+ /*
+ For SP local variable returns address of pointer to Item representing its
+ current value and pointer passed via parameter otherwise.
+ */
+ virtual Item **this_item_addr(THD *thd, Item **addr_arg) { return addr_arg; }
+
+ // Row emulation
+ virtual uint cols() const { return 1; }
+ virtual Item* element_index(uint i) { return this; }
+ virtual Item** addr(uint i) { return 0; }
+ virtual bool check_cols(uint c);
+ bool check_type_traditional_scalar(const char *opname) const;
+ bool check_type_scalar(const char *opname) const;
+ bool check_type_or_binary(const char *opname, const Type_handler *handler) const;
+ bool check_type_general_purpose_string(const char *opname) const;
+ bool check_type_can_return_int(const char *opname) const;
+ bool check_type_can_return_decimal(const char *opname) const;
+ bool check_type_can_return_real(const char *opname) const;
+ bool check_type_can_return_str(const char *opname) const;
+ bool check_type_can_return_text(const char *opname) const;
+ bool check_type_can_return_date(const char *opname) const;
+ bool check_type_can_return_time(const char *opname) const;
+ // It is not row => null inside is impossible
+ virtual bool null_inside() { return 0; }
+ // used in row subselects to get value of elements
+ virtual void bring_value() {}
+
+ const Type_handler *type_handler_long_or_longlong() const
+ {
+ return Type_handler::type_handler_long_or_longlong(max_char_length(),
+ unsigned_flag);
+ }
+
+ /**
+ Create field for temporary table.
+ @param table Temporary table
+ @param [OUT] src Who created the fields
+ @param param Create parameters
+ @retval NULL (on error)
+ @retval a pointer to a newly create Field (on success)
+ */
+ virtual Field *create_tmp_field_ex(MEM_ROOT *root,
+ TABLE *table,
+ Tmp_field_src *src,
+ const Tmp_field_param *param)= 0;
+ virtual Item_field *field_for_view_update() { return 0; }
+
+ virtual Item *neg_transformer(THD *thd) { return NULL; }
+ virtual Item *update_value_transformer(THD *thd, uchar *select_arg)
+ { return this; }
+ virtual Item *expr_cache_insert_transformer(THD *thd, uchar *unused)
+ { return this; }
+ virtual Item *derived_field_transformer_for_having(THD *thd, uchar *arg)
+ { return this; }
+ virtual Item *derived_field_transformer_for_where(THD *thd, uchar *arg)
+ { return this; }
+ virtual Item *grouping_field_transformer_for_where(THD *thd, uchar *arg)
+ { return this; }
+ /* Now is not used. */
+ virtual Item *in_subq_field_transformer_for_where(THD *thd, uchar *arg)
+ { return this; }
+ virtual Item *in_subq_field_transformer_for_having(THD *thd, uchar *arg)
+ { return this; }
+ virtual Item *in_predicate_to_in_subs_transformer(THD *thd, uchar *arg)
+ { return this; }
+ virtual Item *field_transformer_for_having_pushdown(THD *thd, uchar *arg)
+ { return this; }
+ virtual Item *multiple_equality_transformer(THD *thd, uchar *arg)
+ { return this; }
+ virtual bool expr_cache_is_needed(THD *) { return FALSE; }
+ virtual Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs);
+ bool needs_charset_converter(uint32 length, CHARSET_INFO *tocs) const
+ {
+ /*
+ This will return "true" if conversion happens:
+ - between two non-binary different character sets
+ - from "binary" to "unsafe" character set
+ (those that can have non-well-formed string)
+ - from "binary" to UCS2-alike character set with mbminlen>1,
+ when prefix left-padding is needed for an incomplete character:
+ binary 0xFF -> ucs2 0x00FF)
+ */
+ if (!String::needs_conversion_on_storage(length,
+ collation.collation, tocs))
+ return false;
+ /*
+ No needs to add converter if an "arg" is NUMERIC or DATETIME
+ value (which is pure ASCII) and at the same time target DTCollation
+ is ASCII-compatible. For example, no needs to rewrite:
+ SELECT * FROM t1 WHERE datetime_field = '2010-01-01';
+ to
+ SELECT * FROM t1 WHERE CONVERT(datetime_field USING cs) = '2010-01-01';
+
+ TODO: avoid conversion of any values with
+ repertoire ASCII and 7bit-ASCII-compatible,
+ not only numeric/datetime origin.
+ */
+ if (collation.derivation == DERIVATION_NUMERIC &&
+ collation.repertoire == MY_REPERTOIRE_ASCII &&
+ !(collation.collation->state & MY_CS_NONASCII) &&
+ !(tocs->state & MY_CS_NONASCII))
+ return false;
+ return true;
+ }
+ bool needs_charset_converter(CHARSET_INFO *tocs)
+ {
+ // Pass 1 as length to force conversion if tocs->mbminlen>1.
+ return needs_charset_converter(1, tocs);
+ }
+ Item *const_charset_converter(THD *thd, CHARSET_INFO *tocs, bool lossless,
+ const char *func_name);
+ Item *const_charset_converter(THD *thd, CHARSET_INFO *tocs, bool lossless)
+ { return const_charset_converter(thd, tocs, lossless, NULL); }
+ void delete_self()
+ {
+ cleanup();
+ delete this;
+ }
+
+ virtual const Item_const *get_item_const() const { return NULL; }
+ virtual Item_splocal *get_item_splocal() { return 0; }
+ virtual Rewritable_query_parameter *get_rewritable_query_parameter()
+ { return 0; }
+
+ /*
+ Return Settable_routine_parameter interface of the Item. Return 0
+ if this Item is not Settable_routine_parameter.
+ */
+ virtual Settable_routine_parameter *get_settable_routine_parameter()
+ {
+ return 0;
+ }
+
+ virtual Load_data_outvar *get_load_data_outvar()
+ {
+ return 0;
+ }
+ Load_data_outvar *get_load_data_outvar_or_error()
+ {
+ Load_data_outvar *dst= get_load_data_outvar();
+ if (dst)
+ return dst;
+ my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), name.str);
+ return NULL;
+ }
+
+ /**
+ Test whether an expression is expensive to compute. Used during
+ optimization to avoid computing expensive expressions during this
+ phase. Also used to force temp tables when sorting on expensive
+ functions.
+ @todo
+ Normally we should have a method:
+ cost Item::execution_cost(),
+ where 'cost' is either 'double' or some structure of various cost
+ parameters.
+
+ @note
+ This function is now used to prevent evaluation of expensive subquery
+ predicates during the optimization phase. It also prevents evaluation
+ of predicates that are not computable at this moment.
+ */
+ virtual bool is_expensive()
+ {
+ if (is_expensive_cache < 0)
+ is_expensive_cache= walk(&Item::is_expensive_processor, 0, NULL);
+ return MY_TEST(is_expensive_cache);
+ }
+ String *check_well_formed_result(String *str, bool send_error= 0);
+ bool eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs);
+ bool too_big_for_varchar() const
+ { return max_char_length() > CONVERT_IF_BIGGER_TO_BLOB; }
+ void fix_length_and_charset(uint32 max_char_length_arg, CHARSET_INFO *cs)
+ {
+ max_length= char_to_byte_length_safe(max_char_length_arg, cs->mbmaxlen);
+ collation.collation= cs;
+ }
+ void fix_char_length(size_t max_char_length_arg)
+ {
+ max_length= char_to_byte_length_safe(max_char_length_arg,
+ collation.collation->mbmaxlen);
+ }
+ /*
+ Return TRUE if the item points to a column of an outer-joined table.
+ */
+ virtual bool is_outer_field() const { DBUG_ASSERT(is_fixed()); return FALSE; }
+
+ /**
+ Checks if this item or any of its descendents contains a subquery.
+ This is a replacement of the former Item::has_subquery() and
+ Item::with_subselect.
+ */
+ virtual bool with_subquery() const { DBUG_ASSERT(is_fixed()); return false; }
+
+ virtual bool with_sum_func() const { return false; }
+ virtual With_sum_func_cache* get_with_sum_func_cache() { return NULL; }
+
+ Item* set_expr_cache(THD *thd);
+
+ virtual Item_equal *get_item_equal() { return NULL; }
+ virtual void set_item_equal(Item_equal *item_eq) {};
+ virtual Item_equal *find_item_equal(COND_EQUAL *cond_equal) { return NULL; }
+ /**
+ Set the join tab index to the minimal (left-most) JOIN_TAB to which this
+ Item is attached. The number is an index is depth_first_tab() traversal
+ order.
+ */
+ virtual void set_join_tab_idx(uint join_tab_idx_arg)
+ {
+ if (join_tab_idx_arg < join_tab_idx)
+ join_tab_idx= join_tab_idx_arg;
+ }
+ uint get_join_tab_idx() const { return join_tab_idx; }
+
+ table_map view_used_tables(TABLE_LIST *view)
+ {
+ view->view_used_tables= 0;
+ walk(&Item::view_used_tables_processor, 0, view);
+ return view->view_used_tables;
+ }
+
+ /**
+ Collect and add to the list cache parameters for this Item.
+
+ @note Now implemented only for subqueries and in_optimizer,
+ if we need it for general function then this method should
+ be defined for Item_func.
+ */
+ virtual void get_cache_parameters(List<Item> &parameters) { };
+
+ virtual void mark_as_condition_AND_part(TABLE_LIST *embedding) {};
+
+ /* how much position should be reserved for Exists2In transformation */
+ virtual uint exists2in_reserved_items() { return 0; };
+
+ virtual Item *neg(THD *thd);
+
+ /**
+ Inform the item that it is located under a NOT, which is a top-level item.
+ */
+ virtual void under_not(Item_func_not * upper
+ __attribute__((unused))) {};
+ /*
+ If Item_field is wrapped in Item_direct_wrep remove this Item_direct_ref
+ wrapper.
+ */
+ virtual Item *remove_item_direct_ref() { return this; }
+
+
+ void register_in(THD *thd);
+
+ bool depends_only_on(table_map view_map)
+ { return marker & FULL_EXTRACTION_FL; }
+ int get_extraction_flag()
+ { return marker & EXTRACTION_MASK; }
+ void set_extraction_flag(int flags)
+ {
+ marker &= ~EXTRACTION_MASK;
+ marker|= flags;
+ }
+ void clear_extraction_flag()
+ {
+ marker &= ~EXTRACTION_MASK;
+ }
+ void check_pushable_cond(Pushdown_checker excl_dep_func, uchar *arg);
+ bool pushable_cond_checker_for_derived(uchar *arg)
+ {
+ return excl_dep_on_table(*((table_map *)arg));
+ }
+ bool pushable_cond_checker_for_subquery(uchar *arg)
+ {
+ DBUG_ASSERT(((Item*) arg)->get_IN_subquery());
+ return excl_dep_on_in_subq_left_part(((Item*)arg)->get_IN_subquery());
+ }
+ Item *build_pushable_cond(THD *thd,
+ Pushdown_checker checker,
+ uchar *arg);
+ /*
+ Checks if this item depends only on the arg table
+ */
+ bool pushable_equality_checker_for_derived(uchar *arg)
+ {
+ return (used_tables() == *((table_map *)arg));
+ }
+ /*
+ Checks if this item consists in the left part of arg IN subquery predicate
+ */
+ bool pushable_equality_checker_for_subquery(uchar *arg);
+};
+
+MEM_ROOT *get_thd_memroot(THD *thd);
+
+template <class T>
+inline Item* get_item_copy (THD *thd, T* item)
+{
+ Item *copy= new (get_thd_memroot(thd)) T(*item);
+ if (likely(copy))
+ copy->register_in(thd);
+ return copy;
+}
+
+
+#ifndef DBUG_OFF
+/**
+ A helper class to print the data type and the value for an Item
+ in debug builds.
+*/
+class DbugStringItemTypeValue: public StringBuffer<128>
+{
+public:
+ DbugStringItemTypeValue(THD *thd, const Item *item)
+ {
+ append('(');
+ append(item->type_handler()->name().ptr());
+ append(')');
+ const_cast<Item*>(item)->print(this, QT_EXPLAIN);
+ /* Append end \0 to allow usage of c_ptr() */
+ append('\0');
+ str_length--;
+ }
+};
+#endif
+
+class With_sum_func_cache
+{
+protected:
+ bool m_with_sum_func; // True if the owner item contains a sum func
+public:
+ With_sum_func_cache()
+ :m_with_sum_func(false)
+ { }
+ With_sum_func_cache(const Item *a)
+ :m_with_sum_func(a->with_sum_func())
+ { }
+ With_sum_func_cache(const Item *a, const Item *b)
+ :m_with_sum_func(a->with_sum_func() || b->with_sum_func())
+ { }
+ With_sum_func_cache(const Item *a, const Item *b, const Item *c)
+ :m_with_sum_func(a->with_sum_func() || b->with_sum_func() ||
+ c->with_sum_func())
+ { }
+ With_sum_func_cache(const Item *a, const Item *b, const Item *c,
+ const Item *d)
+ :m_with_sum_func(a->with_sum_func() || b->with_sum_func() ||
+ c->with_sum_func() || d->with_sum_func())
+ { }
+ With_sum_func_cache(const Item *a, const Item *b, const Item *c,
+ const Item *d, const Item *e)
+ :m_with_sum_func(a->with_sum_func() || b->with_sum_func() ||
+ c->with_sum_func() || d->with_sum_func() ||
+ e->with_sum_func())
+ { }
+ void set_with_sum_func() { m_with_sum_func= true; }
+ void reset_with_sum_func() { m_with_sum_func= false; }
+ void copy_with_sum_func(const Item *item)
+ {
+ m_with_sum_func= item->with_sum_func();
+ }
+ void join_with_sum_func(const Item *item)
+ {
+ m_with_sum_func|= item->with_sum_func();
+ }
+};
+
+
+/*
+ This class is a replacement for the former member Item::with_subselect.
+ Determines if the descendant Item is a subselect or some of
+ its arguments is or contains a subselect.
+*/
+class With_subquery_cache
+{
+protected:
+ bool m_with_subquery;
+public:
+ With_subquery_cache(): m_with_subquery(false) { }
+ void join(const Item *item) { m_with_subquery|= item->with_subquery(); }
+};
+
+
+/**
+ Compare two Items for List<Item>::add_unique()
+*/
+
+bool cmp_items(Item *a, Item *b);
+
+
+/**
+ Array of items, e.g. function or aggerate function arguments.
+*/
+class Item_args
+{
+protected:
+ Item **args, *tmp_arg[2];
+ uint arg_count;
+ void set_arguments(THD *thd, List<Item> &list);
+ bool walk_args(Item_processor processor, bool walk_subquery, void *arg)
+ {
+ for (uint i= 0; i < arg_count; i++)
+ {
+ if (args[i]->walk(processor, walk_subquery, arg))
+ return true;
+ }
+ return false;
+ }
+ bool transform_args(THD *thd, Item_transformer transformer, uchar *arg);
+ void propagate_equal_fields(THD *, const Item::Context &, COND_EQUAL *);
+ bool excl_dep_on_table(table_map tab_map)
+ {
+ for (uint i= 0; i < arg_count; i++)
+ {
+ if (args[i]->const_item())
+ continue;
+ if (!args[i]->excl_dep_on_table(tab_map))
+ return false;
+ }
+ return true;
+ }
+ bool excl_dep_on_grouping_fields(st_select_lex *sel);
+ bool eq(const Item_args *other, bool binary_cmp) const
+ {
+ for (uint i= 0; i < arg_count ; i++)
+ {
+ if (!args[i]->eq(other->args[i], binary_cmp))
+ return false;
+ }
+ return true;
+ }
+ bool excl_dep_on_in_subq_left_part(Item_in_subselect *subq_pred)
+ {
+ for (uint i= 0; i < arg_count; i++)
+ {
+ if (args[i]->const_item())
+ continue;
+ if (!args[i]->excl_dep_on_in_subq_left_part(subq_pred))
+ return false;
+ }
+ return true;
+ }
+public:
+ Item_args(void)
+ :args(NULL), arg_count(0)
+ { }
+ Item_args(Item *a)
+ :args(tmp_arg), arg_count(1)
+ {
+ args[0]= a;
+ }
+ Item_args(Item *a, Item *b)
+ :args(tmp_arg), arg_count(2)
+ {
+ args[0]= a; args[1]= b;
+ }
+ Item_args(THD *thd, Item *a, Item *b, Item *c)
+ {
+ arg_count= 0;
+ if (likely((args= (Item**) thd_alloc(thd, sizeof(Item*) * 3))))
+ {
+ arg_count= 3;
+ args[0]= a; args[1]= b; args[2]= c;
+ }
+ }
+ Item_args(THD *thd, Item *a, Item *b, Item *c, Item *d)
+ {
+ arg_count= 0;
+ if (likely((args= (Item**) thd_alloc(thd, sizeof(Item*) * 4))))
+ {
+ arg_count= 4;
+ args[0]= a; args[1]= b; args[2]= c; args[3]= d;
+ }
+ }
+ Item_args(THD *thd, Item *a, Item *b, Item *c, Item *d, Item* e)
+ {
+ arg_count= 5;
+ if (likely((args= (Item**) thd_alloc(thd, sizeof(Item*) * 5))))
+ {
+ arg_count= 5;
+ args[0]= a; args[1]= b; args[2]= c; args[3]= d; args[4]= e;
+ }
+ }
+ Item_args(THD *thd, List<Item> &list)
+ {
+ set_arguments(thd, list);
+ }
+ Item_args(THD *thd, const Item_args *other);
+ bool alloc_arguments(THD *thd, uint count);
+ void add_argument(Item *item)
+ {
+ args[arg_count++]= item;
+ }
+ /**
+ Extract row elements from the given position.
+ For example, for this input: (1,2),(3,4),(5,6)
+ pos=0 will extract (1,3,5)
+ pos=1 will extract (2,4,6)
+ @param thd - current thread, to allocate memory on its mem_root
+ @param rows - an array of compatible ROW-type items
+ @param pos - the element position to extract
+ */
+ bool alloc_and_extract_row_elements(THD *thd, const Item_args *rows, uint pos)
+ {
+ DBUG_ASSERT(rows->argument_count() > 0);
+ DBUG_ASSERT(rows->arguments()[0]->cols() > pos);
+ if (alloc_arguments(thd, rows->argument_count()))
+ return true;
+ for (uint i= 0; i < rows->argument_count(); i++)
+ {
+ DBUG_ASSERT(rows->arguments()[0]->cols() == rows->arguments()[i]->cols());
+ Item *arg= rows->arguments()[i]->element_index(pos);
+ add_argument(arg);
+ }
+ DBUG_ASSERT(argument_count() == rows->argument_count());
+ return false;
+ }
+ inline Item **arguments() const { return args; }
+ inline uint argument_count() const { return arg_count; }
+ inline void remove_arguments() { arg_count=0; }
+ Sql_mode_dependency value_depends_on_sql_mode_bit_or() const;
+};
+
+
+/*
+ Class to be used to enumerate all field references in an item tree. This
+ includes references to outside but not fields of the tables within a
+ subquery.
+ Suggested usage:
+
+ class My_enumerator : public Field_enumerator
+ {
+ virtual void visit_field() { ... your actions ...}
+ }
+
+ My_enumerator enumerator;
+ item->walk(Item::enumerate_field_refs_processor, ...,&enumerator);
+
+ This is similar to Visitor pattern.
+*/
+
+class Field_enumerator
+{
+public:
+ virtual void visit_field(Item_field *field)= 0;
+ virtual ~Field_enumerator() {}; /* purecov: inspected */
+ Field_enumerator() {} /* Remove gcc warning */
+};
+
+class Item_string;
+
+
+class Item_fixed_hybrid: public Item
+{
+public:
+ bool fixed; // If item was fixed with fix_fields
+public:
+ Item_fixed_hybrid(THD *thd): Item(thd), fixed(false)
+ { }
+ Item_fixed_hybrid(THD *thd, Item_fixed_hybrid *item)
+ :Item(thd, item), fixed(item->fixed)
+ { }
+ bool fix_fields(THD *thd, Item **ref)
+ {
+ DBUG_ASSERT(!fixed);
+ fixed= true;
+ return false;
+ }
+ void cleanup()
+ {
+ Item::cleanup();
+ fixed= false;
+ }
+ void quick_fix_field() { fixed= true; }
+ void unfix_fields() { fixed= false; }
+ bool is_fixed() const { return fixed; }
+};
+
+
+/**
+ A common class for Item_basic_constant and Item_param
+*/
+class Item_basic_value :public Item,
+ public Item_const
+{
+protected:
+ // Value metadata, e.g. to make string processing easier
+ class Metadata: private MY_STRING_METADATA
+ {
+ public:
+ Metadata(const String *str)
+ {
+ my_string_metadata_get(this, str->charset(), str->ptr(), str->length());
+ }
+ Metadata(const String *str, my_repertoire_t repertoire_arg)
+ {
+ MY_STRING_METADATA::repertoire= repertoire_arg;
+ MY_STRING_METADATA::char_length= str->numchars();
+ }
+ my_repertoire_t repertoire() const
+ {
+ return MY_STRING_METADATA::repertoire;
+ }
+ size_t char_length() const { return MY_STRING_METADATA::char_length; }
+ };
+ void fix_charset_and_length(CHARSET_INFO *cs,
+ Derivation dv, Metadata metadata)
+ {
+ /*
+ We have to have a different max_length than 'length' here to
+ ensure that we get the right length if we do use the item
+ to create a new table. In this case max_length must be the maximum
+ number of chars for a string of this type because we in Create_field::
+ divide the max_length with mbmaxlen).
+ */
+ collation.set(cs, dv, metadata.repertoire());
+ fix_char_length(metadata.char_length());
+ decimals= NOT_FIXED_DEC;
+ }
+ void fix_charset_and_length_from_str_value(const String &str, Derivation dv)
+ {
+ fix_charset_and_length(str.charset(), dv, Metadata(&str));
+ }
+ Item_basic_value(THD *thd): Item(thd) {}
+public:
+ Field *create_tmp_field_ex(MEM_ROOT *root,
+ TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+
+ /*
+ create_tmp_field_ex() for this type of Items is called for:
+ - CREATE TABLE ... SELECT
+ - In ORDER BY: SELECT max(a) FROM t1 GROUP BY a ORDER BY 'const';
+ - In CURSORS:
+ DECLARE c CURSOR FOR SELECT 'test';
+ OPEN c;
+ */
+ return tmp_table_field_from_field_type_maybe_null(root,
+ table, src, param,
+ type() == Item::NULL_ITEM);
+ }
+ bool eq(const Item *item, bool binary_cmp) const override;
+ const Type_all_attributes *get_type_all_attributes_from_const() const
+ override
+ { return this; }
+};
+
+
+class Item_basic_constant :public Item_basic_value
+{
+public:
+ Item_basic_constant(THD *thd): Item_basic_value(thd) {};
+ bool check_vcol_func_processor(void *arg) { return false; }
+ const Item_const *get_item_const() const { return this; }
+ virtual Item_basic_constant *make_string_literal_concat(THD *thd,
+ const LEX_CSTRING *)
+ {
+ DBUG_ASSERT(0);
+ return this;
+ }
+};
+
+
+/*****************************************************************************
+ The class is a base class for representation of stored routine variables in
+ the Item-hierarchy. There are the following kinds of SP-vars:
+ - local variables (Item_splocal);
+ - CASE expression (Item_case_expr);
+*****************************************************************************/
+
+class Item_sp_variable :public Item_fixed_hybrid
+{
+protected:
+ /*
+ THD, which is stored in fix_fields() and is used in this_item() to avoid
+ current_thd use.
+ */
+ THD *m_thd;
+
+ bool fix_fields_from_item(THD *thd, Item **, const Item *);
+public:
+ LEX_CSTRING m_name;
+
+public:
+#ifdef DBUG_ASSERT_EXISTS
+ /*
+ Routine to which this Item_splocal belongs. Used for checking if correct
+ runtime context is used for variable handling.
+ */
+ const sp_head *m_sp;
+#endif
+
+public:
+ Item_sp_variable(THD *thd, const LEX_CSTRING *sp_var_name);
+
+public:
+ bool fix_fields(THD *thd, Item **) override= 0;
+
+ double val_real() override;
+ longlong val_int() override;
+ String *val_str(String *sp) override;
+ my_decimal *val_decimal(my_decimal *decimal_value) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ bool val_native(THD *thd, Native *to) override;
+ bool is_null() override;
+
+public:
+ void make_send_field(THD *thd, Send_field *field) override;
+
+ bool const_item() const override { return true; }
+
+ Field *create_tmp_field_ex(MEM_ROOT *root,
+ TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+ return create_tmp_field_ex_simple(root, table, src, param);
+ }
+ inline int save_in_field(Field *field, bool no_conversions) override;
+ inline bool send(Protocol *protocol, st_value *buffer) override;
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function(m_name.str, arg, VCOL_IMPOSSIBLE);
+ }
+};
+
+/*****************************************************************************
+ Item_sp_variable inline implementation.
+*****************************************************************************/
+
+inline int Item_sp_variable::save_in_field(Field *field, bool no_conversions)
+{
+ return this_item()->save_in_field(field, no_conversions);
+}
+
+inline bool Item_sp_variable::send(Protocol *protocol, st_value *buffer)
+{
+ return this_item()->send(protocol, buffer);
+}
+
+
+/*****************************************************************************
+ A reference to local SP variable (incl. reference to SP parameter), used in
+ runtime.
+*****************************************************************************/
+
+class Item_splocal :public Item_sp_variable,
+ private Settable_routine_parameter,
+ public Rewritable_query_parameter,
+ public Type_handler_hybrid_field_type
+{
+protected:
+ const Sp_rcontext_handler *m_rcontext_handler;
+
+ uint m_var_idx;
+
+ Type m_type;
+
+ bool append_value_for_log(THD *thd, String *str);
+
+ sp_rcontext *get_rcontext(sp_rcontext *local_ctx) const;
+ Item_field *get_variable(sp_rcontext *ctx) const;
+
+public:
+ Item_splocal(THD *thd, const Sp_rcontext_handler *rh,
+ const LEX_CSTRING *sp_var_name, uint sp_var_idx,
+ const Type_handler *handler,
+ uint pos_in_q= 0, uint len_in_q= 0);
+
+ bool fix_fields(THD *, Item **) override;
+ Item *this_item() override;
+ const Item *this_item() const override;
+ Item **this_item_addr(THD *thd, Item **) override;
+
+ void print(String *str, enum_query_type query_type) override;
+
+public:
+ inline const LEX_CSTRING *my_name() const;
+
+ inline uint get_var_idx() const;
+
+ Type type() const override { return m_type; }
+ const Type_handler *type_handler() const override
+ { return Type_handler_hybrid_field_type::type_handler(); }
+ uint cols() const override { return this_item()->cols(); }
+ Item* element_index(uint i) override
+ { return this_item()->element_index(i); }
+ Item** addr(uint i) override { return this_item()->addr(i); }
+ bool check_cols(uint c) override;
+
+private:
+ bool set_value(THD *thd, sp_rcontext *ctx, Item **it) override;
+
+public:
+ Item_splocal *get_item_splocal() override { return this; }
+
+ Rewritable_query_parameter *get_rewritable_query_parameter() override
+ { return this; }
+
+ Settable_routine_parameter *get_settable_routine_parameter() override
+ { return this; }
+
+ bool append_for_log(THD *thd, String *str) override;
+
+ Item *get_copy(THD *) override { return nullptr; }
+
+ /*
+ Override the inherited create_field_for_create_select(),
+ because we want to preserve the exact data type for:
+ DECLARE a1 INT;
+ DECLARE a2 TYPE OF t1.a2;
+ CREATE TABLE t1 AS SELECT a1, a2;
+ The inherited implementation would create a column
+ based on result_type(), which is less exact.
+ */
+ Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table) override
+ { return create_table_field_from_handler(root, table); }
+
+ bool is_valid_limit_clause_variable_with_error() const
+ {
+ /*
+ In case if the variable has an anchored data type, e.g.:
+ DECLARE a TYPE OF t1.a;
+ type_handler() is set to &type_handler_null and this
+ function detects such variable as not valid in LIMIT.
+ */
+ if (type_handler()->is_limit_clause_valid_type())
+ return true;
+ my_error(ER_WRONG_SPVAR_TYPE_IN_LIMIT, MYF(0));
+ return false;
+ }
+};
+
+
+/**
+ An Item_splocal variant whose data type becomes known only at
+ sp_rcontext creation time, e.g. "DECLARE var1 t1.col1%TYPE".
+*/
+class Item_splocal_with_delayed_data_type: public Item_splocal
+{
+public:
+ Item_splocal_with_delayed_data_type(THD *thd,
+ const Sp_rcontext_handler *rh,
+ const LEX_CSTRING *sp_var_name,
+ uint sp_var_idx,
+ uint pos_in_q, uint len_in_q)
+ :Item_splocal(thd, rh, sp_var_name, sp_var_idx, &type_handler_null,
+ pos_in_q, len_in_q)
+ { }
+};
+
+
+/**
+ SP variables that are fields of a ROW.
+ DELCARE r ROW(a INT,b INT);
+ SELECT r.a; -- This is handled by Item_splocal_row_field
+*/
+class Item_splocal_row_field :public Item_splocal
+{
+protected:
+ LEX_CSTRING m_field_name;
+ uint m_field_idx;
+ bool set_value(THD *thd, sp_rcontext *ctx, Item **it) override;
+public:
+ Item_splocal_row_field(THD *thd,
+ const Sp_rcontext_handler *rh,
+ const LEX_CSTRING *sp_var_name,
+ const LEX_CSTRING *sp_field_name,
+ uint sp_var_idx, uint sp_field_idx,
+ const Type_handler *handler,
+ uint pos_in_q= 0, uint len_in_q= 0)
+ :Item_splocal(thd, rh, sp_var_name, sp_var_idx, handler, pos_in_q, len_in_q),
+ m_field_name(*sp_field_name),
+ m_field_idx(sp_field_idx)
+ { }
+ bool fix_fields(THD *thd, Item **) override;
+ Item *this_item() override;
+ const Item *this_item() const override;
+ Item **this_item_addr(THD *thd, Item **) override;
+ bool append_for_log(THD *thd, String *str) override;
+ void print(String *str, enum_query_type query_type) override;
+};
+
+
+class Item_splocal_row_field_by_name :public Item_splocal_row_field
+{
+ bool set_value(THD *thd, sp_rcontext *ctx, Item **it) override;
+public:
+ Item_splocal_row_field_by_name(THD *thd,
+ const Sp_rcontext_handler *rh,
+ const LEX_CSTRING *sp_var_name,
+ const LEX_CSTRING *sp_field_name,
+ uint sp_var_idx,
+ const Type_handler *handler,
+ uint pos_in_q= 0, uint len_in_q= 0)
+ :Item_splocal_row_field(thd, rh, sp_var_name, sp_field_name,
+ sp_var_idx, 0 /* field index will be set later */,
+ handler, pos_in_q, len_in_q)
+ { }
+ bool fix_fields(THD *thd, Item **it) override;
+ void print(String *str, enum_query_type query_type) override;
+};
+
+
+/*****************************************************************************
+ Item_splocal inline implementation.
+*****************************************************************************/
+
+inline const LEX_CSTRING *Item_splocal::my_name() const
+{
+ return &m_name;
+}
+
+inline uint Item_splocal::get_var_idx() const
+{
+ return m_var_idx;
+}
+
+/*****************************************************************************
+ A reference to case expression in SP, used in runtime.
+*****************************************************************************/
+
+class Item_case_expr :public Item_sp_variable
+{
+public:
+ Item_case_expr(THD *thd, uint case_expr_id);
+
+public:
+ bool fix_fields(THD *thd, Item **) override;
+ Item *this_item() override;
+ const Item *this_item() const override;
+ Item **this_item_addr(THD *thd, Item **) override;
+
+ Type type() const override;
+ const Type_handler *type_handler() const override
+ { return this_item()->type_handler(); }
+
+public:
+ /*
+ NOTE: print() is intended to be used from views and for debug.
+ Item_case_expr can not occur in views, so here it is only for debug
+ purposes.
+ */
+ void print(String *str, enum_query_type query_type) override;
+ Item *get_copy(THD *) override { return nullptr; }
+
+private:
+ uint m_case_expr_id;
+};
+
+/*****************************************************************************
+ Item_case_expr inline implementation.
+*****************************************************************************/
+
+inline enum Item::Type Item_case_expr::type() const
+{
+ return this_item()->type();
+}
+
+/*
+ NAME_CONST(given_name, const_value).
+ This 'function' has all properties of the supplied const_value (which is
+ assumed to be a literal constant), and the name given_name.
+
+ This is used to replace references to SP variables when we write PROCEDURE
+ statements into the binary log.
+
+ TODO
+ Together with Item_splocal and Item::this_item() we can actually extract
+ common a base of this class and Item_splocal. Maybe it is possible to
+ extract a common base with class Item_ref, too.
+*/
+
+class Item_name_const : public Item_fixed_hybrid
+{
+ Item *value_item;
+ Item *name_item;
+public:
+ Item_name_const(THD *thd, Item *name_arg, Item *val);
+
+ bool fix_fields(THD *, Item **) override;
+
+ Type type() const override;
+ double val_real() override;
+ longlong val_int() override;
+ String *val_str(String *sp) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ bool val_native(THD *thd, Native *to) override;
+ bool is_null() override;
+ void print(String *str, enum_query_type query_type) override;
+
+ const Type_handler *type_handler() const override
+ {
+ return value_item->type_handler();
+ }
+
+ bool const_item() const override { return true; }
+
+ Field *create_tmp_field_ex(MEM_ROOT *root,
+ TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+ /*
+ We can get to here when using a CURSOR for a query with NAME_CONST():
+ DECLARE c CURSOR FOR SELECT NAME_CONST('x','y') FROM t1;
+ OPEN c;
+ */
+ return tmp_table_field_from_field_type_maybe_null(root, table, src, param,
+ type() == Item::NULL_ITEM);
+ }
+ int save_in_field(Field *field, bool no_conversions) override
+ {
+ return value_item->save_in_field(field, no_conversions);
+ }
+
+ bool send(Protocol *protocol, st_value *buffer) override
+ {
+ return value_item->send(protocol, buffer);
+ }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function("name_const()", arg, VCOL_IMPOSSIBLE);
+ }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_name_const>(thd, this); }
+};
+
+
+class Item_literal: public Item_basic_constant
+{
+public:
+ Item_literal(THD *thd): Item_basic_constant(thd)
+ { }
+ Type type() const override { return CONST_ITEM; }
+ bool check_partition_func_processor(void *) override { return false;}
+ bool const_item() const override { return true; }
+ bool basic_const_item() const override { return true; }
+};
+
+
+class Item_num: public Item_literal
+{
+public:
+ Item_num(THD *thd): Item_literal(thd) { collation= DTCollation_numeric(); }
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override;
+ 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);
+ }
+};
+
+#define NO_CACHED_FIELD_INDEX ((uint)(-1))
+
+class st_select_lex;
+
+
+class Item_result_field :public Item_fixed_hybrid /* Item with result field */
+{
+protected:
+ Field *create_tmp_field_ex_from_handler(MEM_ROOT *root, TABLE *table,
+ Tmp_field_src *src,
+ const Tmp_field_param *param,
+ const Type_handler *h);
+public:
+ Field *result_field; /* Save result here */
+ Item_result_field(THD *thd): Item_fixed_hybrid(thd), result_field(0) {}
+ // Constructor used for Item_sum/Item_cond_and/or (see Item comment)
+ Item_result_field(THD *thd, Item_result_field *item):
+ Item_fixed_hybrid(thd, item), result_field(item->result_field)
+ {}
+ ~Item_result_field() {} /* Required with gcc 2.95 */
+ Field *get_tmp_table_field() override { return result_field; }
+ Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+ DBUG_ASSERT(fixed);
+ const Type_handler *h= type_handler()->type_handler_for_tmp_table(this);
+ return create_tmp_field_ex_from_handler(root, table, src, param, h);
+ }
+ void get_tmp_field_src(Tmp_field_src *src, const Tmp_field_param *param);
+ /*
+ This implementation of used_tables() used by Item_avg_field and
+ Item_variance_field which work when only temporary table left, so theu
+ return table map of the temporary table.
+ */
+ table_map used_tables() const override { return 1; }
+ bool is_result_field() override { return true; }
+ void save_in_result_field(bool no_conversions) override
+ {
+ save_in_field(result_field, no_conversions);
+ }
+ void cleanup() override;
+ bool check_vcol_func_processor(void *) override { return false; }
+};
+
+
+class Item_ident :public Item_result_field
+{
+protected:
+ /*
+ We have to store initial values of db_name, table_name and field_name
+ to be able to restore them during cleanup() because they can be
+ updated during fix_fields() to values from Field object and life-time
+ of those is shorter than life-time of Item_field.
+ */
+ LEX_CSTRING orig_db_name;
+ LEX_CSTRING orig_table_name;
+ LEX_CSTRING orig_field_name;
+
+ void undeclared_spvar_error() const;
+
+public:
+ Name_resolution_context *context;
+ LEX_CSTRING db_name;
+ LEX_CSTRING table_name;
+ LEX_CSTRING field_name;
+ bool alias_name_used; /* true if item was resolved against alias */
+ /*
+ Cached value of index for this field in table->field array, used by prep.
+ stmts for speeding up their re-execution. Holds NO_CACHED_FIELD_INDEX
+ if index value is not known.
+ */
+ uint cached_field_index;
+ /*
+ Cached pointer to table which contains this field, used for the same reason
+ by prep. stmt. too in case then we have not-fully qualified field.
+ 0 - means no cached value.
+ */
+ TABLE_LIST *cached_table;
+ st_select_lex *depended_from;
+ /*
+ Some Items resolved in another select should not be marked as dependency
+ of the subquery where they are. During normal name resolution, we check
+ this. Stored procedures and prepared statements first try to resolve an
+ ident item using a cached table reference and field position from the
+ previous query execution (cached_table/cached_field_index). If the
+ tables were not changed, the ident matches the table/field, and we have
+ faster resolution of the ident without looking through all tables and
+ fields in the query. But in this case, we can not check all conditions
+ about this ident item dependency, so we should cache the condition in
+ this variable.
+ */
+ bool can_be_depended;
+ Item_ident(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &db_name_arg, const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg);
+ Item_ident(THD *thd, Item_ident *item);
+ Item_ident(THD *thd, TABLE_LIST *view_arg, const LEX_CSTRING &field_name_arg);
+ const char *full_name() const override;
+ void cleanup() override;
+ st_select_lex *get_depended_from() const;
+ bool remove_dependence_processor(void * arg) override;
+ void print(String *str, enum_query_type query_type) override;
+ bool change_context_processor(void *cntx) override
+ { context= (Name_resolution_context *)cntx; return FALSE; }
+ /**
+ Collect outer references
+ */
+ bool collect_outer_ref_processor(void *arg) override;
+ friend bool insert_fields(THD *thd, Name_resolution_context *context,
+ const char *db_name,
+ const char *table_name, List_iterator<Item> *it,
+ bool any_privileges, bool returning_field);
+};
+
+
+class Item_field :public Item_ident,
+ public Load_data_outvar
+{
+protected:
+ void set_field(Field *field);
+public:
+ Field *field;
+ Item_equal *item_equal;
+ /*
+ if any_privileges set to TRUE then here real effective privileges will
+ be stored
+ */
+ privilege_t have_privileges;
+ /* field need any privileges (for VIEW creation) */
+ bool any_privileges;
+ Item_field(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &db_arg, const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg);
+ Item_field(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &field_name_arg)
+ :Item_field(thd, context_arg, null_clex_str, null_clex_str, field_name_arg)
+ { }
+ Item_field(THD *thd, Name_resolution_context *context_arg)
+ :Item_field(thd, context_arg, null_clex_str, null_clex_str, null_clex_str)
+ { }
+ /*
+ Constructor needed to process subselect with temporary tables (see Item)
+ */
+ Item_field(THD *thd, Item_field *item);
+ /*
+ Constructor used inside setup_wild(), ensures that field, table,
+ and database names will live as long as Item_field (this is important
+ in prepared statements).
+ */
+ Item_field(THD *thd, Name_resolution_context *context_arg, Field *field);
+ /*
+ If this constructor is used, fix_fields() won't work, because
+ db_name, table_name and column_name are unknown. It's necessary to call
+ reset_field() before fix_fields() for all fields created this way.
+ */
+ Item_field(THD *thd, Field *field);
+ Type type() const override { return FIELD_ITEM; }
+ bool eq(const Item *item, bool binary_cmp) const override;
+ double val_real() override;
+ longlong val_int() override;
+ my_decimal *val_decimal(my_decimal *) override;
+ String *val_str(String*) override;
+ void save_result(Field *to) override;
+ double val_result() override;
+ longlong val_int_result() override;
+ bool val_native(THD *thd, Native *to) override;
+ bool val_native_result(THD *thd, Native *to) override;
+ String *str_result(String* tmp) override;
+ my_decimal *val_decimal_result(my_decimal *) override;
+ bool val_bool_result() override;
+ bool is_null_result() override;
+ bool is_json_type() override;
+ bool send(Protocol *protocol, st_value *buffer) override;
+ Load_data_outvar *get_load_data_outvar() override { return this; }
+ bool load_data_set_null(THD *thd, const Load_data_param *param) override
+ {
+ return field->load_data_set_null(thd);
+ }
+ bool load_data_set_value(THD *thd, const char *pos, uint length,
+ const Load_data_param *param) override
+ {
+ field->load_data_set_value(pos, length, param->charset());
+ return false;
+ }
+ bool load_data_set_no_data(THD *thd, const Load_data_param *param) override;
+ void load_data_print_for_log_event(THD *thd, String *to) const override;
+ bool load_data_add_outvar(THD *thd, Load_data_param *param) const override
+ {
+ return param->add_outvar_field(thd, field);
+ }
+ uint load_data_fixed_length() const override
+ {
+ return field->field_length;
+ }
+ void reset_field(Field *f);
+ bool fix_fields(THD *, Item **) override;
+ void fix_after_pullout(st_select_lex *new_parent, Item **ref, bool merge)
+ override;
+ void make_send_field(THD *thd, Send_field *tmp_field) override;
+ int save_in_field(Field *field,bool no_conversions) override;
+ void save_org_in_field(Field *field, fast_field_copier optimizer_data)
+ override;
+ fast_field_copier setup_fast_field_copier(Field *field) override;
+ table_map used_tables() const override;
+ table_map all_used_tables() const override;
+ const Type_handler *type_handler() const override
+ {
+ const Type_handler *handler= field->type_handler();
+ return handler->type_handler_for_item_field();
+ }
+ const Type_handler *real_type_handler() const override
+ {
+ if (field->is_created_from_null_item)
+ return &type_handler_null;
+ return field->type_handler();
+ }
+ Field *create_tmp_field_from_item_field(MEM_ROOT *root, TABLE *new_table,
+ Item_ref *orig_item,
+ const Tmp_field_param *param);
+ Field *create_tmp_field_ex(MEM_ROOT *root,
+ TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override;
+ const TYPELIB *get_typelib() const override { return field->get_typelib(); }
+ enum_monotonicity_info get_monotonicity_info() const override
+ {
+ return MONOTONIC_STRICT_INCREASING;
+ }
+ Sql_mode_dependency value_depends_on_sql_mode() const override
+ {
+ return Sql_mode_dependency(0, field->value_depends_on_sql_mode());
+ }
+ longlong val_int_endpoint(bool left_endp, bool *incl_endp) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ bool get_date_result(THD *thd, MYSQL_TIME *ltime,date_mode_t fuzzydate)
+ override;
+ longlong val_datetime_packed(THD *thd) override;
+ longlong val_time_packed(THD *thd) override;
+ bool is_null() override { return field->is_null(); }
+ void update_null_value() override;
+ void update_table_bitmaps()
+ {
+ if (field && field->table)
+ {
+ TABLE *tab= field->table;
+ tab->covering_keys.intersect(field->part_of_key);
+ if (tab->read_set)
+ tab->mark_column_with_deps(field);
+ }
+ }
+ void update_used_tables() override
+ {
+ update_table_bitmaps();
+ }
+ COND *build_equal_items(THD *thd, COND_EQUAL *inherited,
+ bool link_item_fields,
+ COND_EQUAL **cond_equal_ref) override
+ {
+ /*
+ normilize_cond() replaced all conditions of type
+ WHERE/HAVING field
+ to:
+ WHERE/HAVING field<>0
+ By the time of a build_equal_items() call, all such conditions should
+ already be replaced. No Item_field are possible.
+ Note, some Item_field derivants are still possible.
+ Item_insert_value:
+ SELECT * FROM t1 WHERE VALUES(a);
+ Item_default_value:
+ SELECT * FROM t1 WHERE DEFAULT(a);
+ */
+ DBUG_ASSERT(type() != FIELD_ITEM);
+ return Item_ident::build_equal_items(thd, inherited, link_item_fields,
+ cond_equal_ref);
+ }
+ bool is_result_field() override { return false; }
+ void save_in_result_field(bool no_conversions) override;
+ Item *get_tmp_table_item(THD *thd) override;
+ bool find_not_null_fields(table_map allowed) override;
+ bool collect_item_field_processor(void * arg) override;
+ bool unknown_splocal_processor(void *arg) override;
+ bool add_field_to_set_processor(void * arg) override;
+ bool find_item_in_field_list_processor(void *arg) override;
+ bool register_field_in_read_map(void *arg) override;
+ bool register_field_in_write_map(void *arg) override;
+ bool register_field_in_bitmap(void *arg) override;
+ bool check_partition_func_processor(void *) override {return false;}
+ bool post_fix_fields_part_expr_processor(void *bool_arg) override;
+ bool check_valid_arguments_processor(void *bool_arg) override;
+ bool check_field_expression_processor(void *arg) override;
+ bool enumerate_field_refs_processor(void *arg) override;
+ bool update_table_bitmaps_processor(void *arg) override;
+ bool switch_to_nullable_fields_processor(void *arg) override;
+ bool update_vcol_processor(void *arg) override;
+ bool rename_fields_processor(void *arg) override;
+ bool check_vcol_func_processor(void *arg) override;
+ bool set_fields_as_dependent_processor(void *arg) override
+ {
+ if (!(used_tables() & OUTER_REF_TABLE_BIT))
+ {
+ depended_from= (st_select_lex *) arg;
+ item_equal= NULL;
+ }
+ return 0;
+ }
+ bool check_table_name_processor(void *arg) override
+ {
+ Check_table_name_prm &p= *static_cast<Check_table_name_prm*>(arg);
+ if (!field && p.table_name.length && table_name.length)
+ {
+ DBUG_ASSERT(p.db.length);
+ if ((db_name.length &&
+ my_strcasecmp(table_alias_charset, p.db.str, db_name.str)) ||
+ my_strcasecmp(table_alias_charset, p.table_name.str, table_name.str))
+ {
+ print(&p.field, (enum_query_type) (QT_ITEM_ORIGINAL_FUNC_NULLIF |
+ QT_NO_DATA_EXPANSION |
+ QT_TO_SYSTEM_CHARSET));
+ return true;
+ }
+ }
+ return false;
+ }
+ void cleanup() override;
+ Item_equal *get_item_equal() override { return item_equal; }
+ void set_item_equal(Item_equal *item_eq) override { item_equal= item_eq; }
+ Item_equal *find_item_equal(COND_EQUAL *cond_equal) override;
+ Item* propagate_equal_fields(THD *, const Context &, COND_EQUAL *) override;
+ Item *replace_equal_field(THD *thd, uchar *arg) override;
+ uint32 max_display_length() const override
+ { return field->max_display_length(); }
+ Item_field *field_for_view_update() override { return this; }
+ int fix_outer_field(THD *thd, Field **field, Item **reference);
+ Item *update_value_transformer(THD *thd, uchar *select_arg) override;
+ Item *derived_field_transformer_for_having(THD *thd, uchar *arg) override;
+ Item *derived_field_transformer_for_where(THD *thd, uchar *arg) override;
+ Item *grouping_field_transformer_for_where(THD *thd, uchar *arg) override;
+ Item *in_subq_field_transformer_for_where(THD *thd, uchar *arg) override;
+ Item *in_subq_field_transformer_for_having(THD *thd, uchar *arg) override;
+ void print(String *str, enum_query_type query_type) override;
+ bool excl_dep_on_table(table_map tab_map) override;
+ bool excl_dep_on_grouping_fields(st_select_lex *sel) override;
+ bool excl_dep_on_in_subq_left_part(Item_in_subselect *subq_pred) override;
+ bool cleanup_excluding_fields_processor(void *arg) override
+ { return field ? 0 : cleanup_processor(arg); }
+ bool cleanup_excluding_const_fields_processor(void *arg) override
+ { return field && const_item() ? 0 : cleanup_processor(arg); }
+
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_field>(thd, this); }
+ bool is_outer_field() const override
+ {
+ DBUG_ASSERT(fixed);
+ return field->table->pos_in_table_list->outer_join;
+ }
+ bool check_index_dependence(void *arg) override;
+ friend class Item_default_value;
+ friend class Item_insert_value;
+ friend class st_select_lex_unit;
+};
+
+
+/**
+ Item_field for the ROW data type
+*/
+class Item_field_row: public Item_field,
+ public Item_args
+{
+public:
+ Item_field_row(THD *thd, Field *field)
+ :Item_field(thd, field),
+ Item_args()
+ { }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_field_row>(thd, this); }
+
+ const Type_handler *type_handler() const override
+ { return &type_handler_row; }
+ uint cols() const override { return arg_count; }
+ Item* element_index(uint i) override { return arg_count ? args[i] : this; }
+ Item** addr(uint i) override { return arg_count ? args + i : NULL; }
+ bool check_cols(uint c) override
+ {
+ if (cols() != c)
+ {
+ my_error(ER_OPERAND_COLUMNS, MYF(0), c);
+ return true;
+ }
+ return false;
+ }
+ bool row_create_items(THD *thd, List<Spvar_definition> *list);
+};
+
+
+/*
+ @brief
+ Item_temptable_field is the same as Item_field, except that print()
+ continues to work even if the table has been dropped.
+
+ @detail
+
+ We need this item for "ANALYZE statement" feature. Query execution has
+ these steps:
+
+ 1. Run the query.
+ 2. Cleanup starts. Temporary tables are destroyed
+ 3. print "ANALYZE statement" output, if needed
+ 4. Call close_thread_table() for regular tables.
+
+ Step #4 is done after step #3, so "ANALYZE stmt" has no problem printing
+ Item_field objects that refer to regular tables.
+
+ However, Step #3 is done after Step #2. Attempt to print Item_field objects
+ that refer to temporary tables will cause access to freed memory.
+
+ To resolve this, we use Item_temptable_field to refer to items in temporary
+ (work) tables.
+*/
+
+class Item_temptable_field :public Item_field
+{
+public:
+ Item_temptable_field(THD *thd, Name_resolution_context *context_arg, Field *field)
+ : Item_field(thd, context_arg, field) {}
+
+ Item_temptable_field(THD *thd, Field *field)
+ : Item_field(thd, field) {}
+
+ Item_temptable_field(THD *thd, Item_field *item) : Item_field(thd, item) {};
+
+ void print(String *str, enum_query_type query_type) override;
+};
+
+
+class Item_null :public Item_basic_constant
+{
+public:
+ Item_null(THD *thd, const char *name_par=0, CHARSET_INFO *cs= &my_charset_bin):
+ Item_basic_constant(thd)
+ {
+ maybe_null= null_value= TRUE;
+ max_length= 0;
+ name.str= name_par ? name_par : "NULL";
+ name.length= strlen(name.str);
+ collation.set(cs, DERIVATION_IGNORABLE, MY_REPERTOIRE_ASCII);
+ }
+ Type type() const override { return NULL_ITEM; }
+ bool vcol_assignment_allowed_value() const override { return true; }
+ double val_real() override;
+ longlong val_int() override;
+ String *val_str(String *str) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ longlong val_datetime_packed(THD *) override;
+ longlong val_time_packed(THD *) override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ int save_safe_in_field(Field *field) override;
+ bool send(Protocol *protocol, st_value *buffer) override;
+ const Type_handler *type_handler() const override
+ { return &type_handler_null; }
+ bool basic_const_item() const override { return true; }
+ Item *clone_item(THD *thd) override;
+ bool const_is_null() const override { return true; }
+ bool is_null() override { return true; }
+
+ void print(String *str, enum_query_type) override
+ {
+ str->append(STRING_WITH_LEN("NULL"));
+ }
+
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override;
+ bool check_partition_func_processor(void *) override { return false; }
+ Item_basic_constant *make_string_literal_concat(THD *thd,
+ const LEX_CSTRING *)
+ override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_null>(thd, this); }
+};
+
+class Item_null_result :public Item_null
+{
+public:
+ Field *result_field;
+ Item_null_result(THD *thd): Item_null(thd), result_field(0) {}
+ bool is_result_field() override { return result_field != 0; }
+ const Type_handler *type_handler() const override
+ {
+ if (result_field)
+ return result_field->type_handler();
+ return &type_handler_null;
+ }
+ Field *create_tmp_field_ex(MEM_ROOT *, TABLE *, Tmp_field_src *,
+ const Tmp_field_param *) override
+ {
+ DBUG_ASSERT(0);
+ return NULL;
+ }
+ void save_in_result_field(bool no_conversions) override
+ {
+ save_in_field(result_field, no_conversions);
+ }
+ bool check_partition_func_processor(void *) override { return true; }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function(full_name(), arg, VCOL_IMPOSSIBLE);
+ }
+};
+
+/*
+ Item represents one placeholder ('?') of prepared statement
+
+ Notes:
+ Item_param::field_type() is used when this item is in a temporary table.
+ This is NOT placeholder metadata sent to client, as this value
+ is assigned after sending metadata (in setup_one_conversion_function).
+ For example in case of 'SELECT ?' you'll get MYSQL_TYPE_STRING both
+ in result set and placeholders metadata, no matter what type you will
+ supply for this placeholder in mysql_stmt_execute.
+
+ Item_param has two Type_handler pointers,
+ which can point to different handlers:
+
+ 1. In the Type_handler_hybrid_field_type member
+ It's initialized in:
+ - Item_param::setup_conversion(), for client-server PS protocol,
+ according to the bind type.
+ - Item_param::set_from_item(), for EXECUTE and EXECUTE IMMEDIATE,
+ according to the actual parameter data type.
+
+ 2. In the "value" member.
+ It's initialized in:
+ - Item_param::set_param_func(), for client-server PS protocol.
+ - Item_param::set_from_item(), for EXECUTE and EXECUTE IMMEDIATE.
+*/
+
+class Item_param :public Item_basic_value,
+ private Settable_routine_parameter,
+ public Rewritable_query_parameter,
+ private Type_handler_hybrid_field_type
+{
+ /*
+ NO_VALUE is a special value meaning that the parameter has not been
+ assigned yet. Item_param::state is assigned to NO_VALUE in constructor
+ and is used at prepare time.
+
+ 1. At prepare time
+ Item_param::fix_fields() sets "fixed" to true,
+ but as Item_param::state is still NO_VALUE,
+ Item_param::basic_const_item() returns false. This prevents various
+ optimizations to happen at prepare time fix_fields().
+ For example, in this query:
+ PREPARE stmt FROM 'SELECT FORMAT(10000,2,?)';
+ Item_param::basic_const_item() is tested from
+ Item_func_format::fix_length_and_dec().
+
+ 2. At execute time:
+ When Item_param gets a value
+ (or a pseudo-value like DEFAULT_VALUE or IGNORE_VALUE):
+ - Item_param::state changes from NO_VALUE to something else
+ - Item_param::fixed is changed to true
+ All Item_param::set_xxx() make sure to do so.
+ In the state with an assigned value:
+ - Item_param::basic_const_item() returns true
+ - Item::type() returns NULL_ITEM or CONST_ITEM,
+ depending on the value assigned.
+ So in this state Item_param behaves in many cases like a literal.
+
+ When Item_param::cleanup() is called:
+ - Item_param::state does not change
+ - Item_param::fixed changes to false
+ Note, this puts Item_param into an inconsistent state:
+ - Item_param::basic_const_item() still returns "true"
+ - Item_param::type() still pretends to be a basic constant Item
+ Both are not expected in combination with fixed==false.
+ However, these methods are not really called in this state,
+ see asserts in Item_param::basic_const_item() and Item_param::type().
+
+ When Item_param::reset() is called:
+ - Item_param::state changes to NO_VALUE
+ - Item_param::fixed changes to false
+ */
+ enum enum_item_param_state
+ {
+ NO_VALUE, NULL_VALUE, SHORT_DATA_VALUE, LONG_DATA_VALUE,
+ DEFAULT_VALUE, IGNORE_VALUE
+ } state;
+
+ void fix_temporal(uint32 max_length_arg, uint decimals_arg);
+
+ struct CONVERSION_INFO
+ {
+ /*
+ Character sets conversion info for string values.
+ Character sets of client and connection defined at bind time are used
+ for all conversions, even if one of them is later changed (i.e.
+ between subsequent calls to mysql_stmt_execute).
+ */
+ CHARSET_INFO *character_set_client;
+ CHARSET_INFO *character_set_of_placeholder;
+ /*
+ This points at character set of connection if conversion
+ to it is required (i. e. if placeholder typecode is not BLOB).
+ Otherwise it's equal to character_set_client (to simplify
+ check in convert_str_value()).
+ */
+ CHARSET_INFO *final_character_set_of_str_value;
+ private:
+ bool needs_conversion() const
+ {
+ return final_character_set_of_str_value !=
+ character_set_of_placeholder;
+ }
+ bool convert(THD *thd, String *str);
+ public:
+ void set(THD *thd, CHARSET_INFO *cs);
+ bool convert_if_needed(THD *thd, String *str)
+ {
+ /*
+ Check is so simple because all charsets were set up properly
+ in setup_one_conversion_function, where typecode of
+ placeholder was also taken into account: the variables are different
+ here only if conversion is really necessary.
+ */
+ if (needs_conversion())
+ return convert(thd, str);
+ str->set_charset(final_character_set_of_str_value);
+ return false;
+ }
+ };
+
+ bool m_empty_string_is_null;
+
+ class PValue_simple
+ {
+ public:
+ union
+ {
+ longlong integer;
+ double real;
+ CONVERSION_INFO cs_info;
+ MYSQL_TIME time;
+ };
+ void swap(PValue_simple &other)
+ {
+ swap_variables(PValue_simple, *this, other);
+ }
+ };
+
+ class PValue: public Type_handler_hybrid_field_type,
+ public PValue_simple,
+ public Value_source
+ {
+ public:
+ PValue(): Type_handler_hybrid_field_type(&type_handler_null) {}
+ my_decimal m_decimal;
+ String m_string;
+ /*
+ A buffer for string and long data values. Historically all allocated
+ values returned from val_str() were treated as eligible to
+ modification. I. e. in some cases Item_func_concat can append it's
+ second argument to return value of the first one. Because of that we
+ can't return the original buffer holding string data from val_str(),
+ and have to have one buffer for data and another just pointing to
+ the data. This is the latter one and it's returned from val_str().
+ Can not be declared inside the union as it's not a POD type.
+ */
+ String m_string_ptr;
+
+ void swap(PValue &other)
+ {
+ Type_handler_hybrid_field_type::swap(other);
+ PValue_simple::swap(other);
+ m_decimal.swap(other.m_decimal);
+ m_string.swap(other.m_string);
+ m_string_ptr.swap(other.m_string_ptr);
+ }
+ double val_real(const Type_std_attributes *attr) const;
+ longlong val_int(const Type_std_attributes *attr) const;
+ my_decimal *val_decimal(my_decimal *dec, const Type_std_attributes *attr);
+ String *val_str(String *str, const Type_std_attributes *attr);
+ };
+
+ PValue value;
+
+ const String *value_query_val_str(THD *thd, String* str) const;
+ Item *value_clone_item(THD *thd);
+ bool is_evaluable_expression() const override;
+ bool can_return_value() const;
+
+public:
+ /*
+ Used for bulk protocol only.
+ */
+ enum enum_indicator_type indicator;
+
+ const Type_handler *type_handler() const override
+ { return Type_handler_hybrid_field_type::type_handler(); }
+
+ bool vcol_assignment_allowed_value() const override
+ {
+ switch (state) {
+ case NULL_VALUE:
+ case DEFAULT_VALUE:
+ case IGNORE_VALUE:
+ return true;
+ case NO_VALUE:
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ break;
+ }
+ return false;
+ }
+
+ Item_param(THD *thd, const LEX_CSTRING *name_arg,
+ uint pos_in_query_arg, uint len_in_query_arg);
+
+ Type type() const override
+ {
+ // Don't pretend to be a constant unless value for this item is set.
+ switch (state) {
+ case NO_VALUE: return PARAM_ITEM;
+ case NULL_VALUE: return NULL_ITEM;
+ case SHORT_DATA_VALUE: return CONST_ITEM;
+ case LONG_DATA_VALUE: return CONST_ITEM;
+ case DEFAULT_VALUE: return PARAM_ITEM;
+ case IGNORE_VALUE: return PARAM_ITEM;
+ }
+ DBUG_ASSERT(0);
+ return PARAM_ITEM;
+ }
+
+ bool is_order_clause_position() const override
+ {
+ return state == SHORT_DATA_VALUE &&
+ type_handler()->is_order_clause_position_type();
+ }
+
+ const Item_const *get_item_const() const override
+ {
+ switch (state) {
+ case SHORT_DATA_VALUE:
+ case LONG_DATA_VALUE:
+ case NULL_VALUE:
+ return this;
+ case IGNORE_VALUE:
+ case DEFAULT_VALUE:
+ case NO_VALUE:
+ break;
+ }
+ return NULL;
+ }
+
+ bool const_is_null() const override { return state == NULL_VALUE; }
+ bool can_return_const_value(Item_result type) const
+ {
+ return can_return_value() &&
+ value.type_handler()->cmp_type() == type &&
+ type_handler()->cmp_type() == type;
+ }
+ const longlong *const_ptr_longlong() const override
+ { return can_return_const_value(INT_RESULT) ? &value.integer : NULL; }
+ const double *const_ptr_double() const override
+ { return can_return_const_value(REAL_RESULT) ? &value.real : NULL; }
+ const my_decimal *const_ptr_my_decimal() const override
+ { return can_return_const_value(DECIMAL_RESULT) ? &value.m_decimal : NULL; }
+ const MYSQL_TIME *const_ptr_mysql_time() const override
+ { return can_return_const_value(TIME_RESULT) ? &value.time : NULL; }
+ const String *const_ptr_string() const override
+ { return can_return_const_value(STRING_RESULT) ? &value.m_string : NULL; }
+
+ double val_real() override
+ {
+ return can_return_value() ? value.val_real(this) : 0e0;
+ }
+ longlong val_int() override
+ {
+ return can_return_value() ? value.val_int(this) : 0;
+ }
+ my_decimal *val_decimal(my_decimal *dec) override
+ {
+ return can_return_value() ? value.val_decimal(dec, this) : NULL;
+ }
+ String *val_str(String *str) override
+ {
+ return can_return_value() ? value.val_str(str, this) : NULL;
+ }
+ bool get_date(THD *thd, MYSQL_TIME *tm, date_mode_t fuzzydate) override;
+ bool val_native(THD *thd, Native *to) override
+ {
+ return Item_param::type_handler()->Item_param_val_native(thd, this, to);
+ }
+
+ int save_in_field(Field *field, bool no_conversions) override;
+
+ void set_default();
+ void set_ignore();
+ void set_null();
+ void set_int(longlong i, uint32 max_length_arg);
+ void set_double(double i);
+ void set_decimal(const char *str, ulong length);
+ void set_decimal(const my_decimal *dv, bool unsigned_arg);
+ bool set_str(const char *str, ulong length,
+ CHARSET_INFO *fromcs, CHARSET_INFO *tocs);
+ bool set_longdata(const char *str, ulong length);
+ void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
+ void set_time(const MYSQL_TIME *tm, uint32 max_length_arg, uint decimals_arg);
+ bool set_from_item(THD *thd, Item *item);
+ void reset();
+
+ void set_param_tiny(uchar **pos, ulong len);
+ void set_param_short(uchar **pos, ulong len);
+ void set_param_int32(uchar **pos, ulong len);
+ void set_param_int64(uchar **pos, ulong len);
+ void set_param_float(uchar **pos, ulong len);
+ void set_param_double(uchar **pos, ulong len);
+ void set_param_decimal(uchar **pos, ulong len);
+ void set_param_time(uchar **pos, ulong len);
+ void set_param_datetime(uchar **pos, ulong len);
+ void set_param_date(uchar **pos, ulong len);
+ void set_param_str(uchar **pos, ulong len);
+
+ void setup_conversion(THD *thd, uchar param_type);
+ void setup_conversion_blob(THD *thd);
+ void setup_conversion_string(THD *thd, CHARSET_INFO *fromcs);
+
+ /*
+ Assign placeholder value from bind data.
+ Note, that 'len' has different semantics in embedded library (as we
+ don't need to check that packet is not broken there). See
+ sql_prepare.cc for details.
+ */
+ void set_param_func(uchar **pos, ulong len)
+ {
+ /*
+ To avoid Item_param::set_xxx() asserting on data type mismatch,
+ we set the value type handler here:
+ - It can not be initialized yet after Item_param::setup_conversion().
+ - Also, for LIMIT clause parameters, the value type handler might have
+ changed from the real type handler to type_handler_longlong.
+ So here we'll restore it.
+ */
+ const Type_handler *h= Item_param::type_handler();
+ value.set_handler(h);
+ h->Item_param_set_param_func(this, pos, len);
+ }
+
+ bool set_value(THD *thd, const Type_all_attributes *attr,
+ const st_value *val, const Type_handler *h)
+ {
+ value.set_handler(h); // See comments in set_param_func()
+ return h->Item_param_set_from_value(thd, this, attr, val);
+ }
+
+ bool set_limit_clause_param(longlong nr)
+ {
+ value.set_handler(&type_handler_slonglong);
+ set_int(nr, MY_INT64_NUM_DECIMAL_DIGITS);
+ return !unsigned_flag && value.integer < 0;
+ }
+ const String *query_val_str(THD *thd, String *str) const;
+
+ bool convert_str_value(THD *thd);
+
+ /*
+ If value for parameter was not set we treat it as non-const
+ so no one will use parameters value in fix_fields still
+ parameter is constant during execution.
+ */
+ bool const_item() const override
+ {
+ return state != NO_VALUE;
+ }
+ table_map used_tables() const override
+ {
+ return state != NO_VALUE ? (table_map)0 : PARAM_TABLE_BIT;
+ }
+ void print(String *str, enum_query_type query_type) override;
+ bool is_null() override
+ { DBUG_ASSERT(state != NO_VALUE); return state == NULL_VALUE; }
+ bool basic_const_item() const override;
+ bool has_no_value() const
+ {
+ return state == NO_VALUE;
+ }
+ bool has_long_data_value() const
+ {
+ return state == LONG_DATA_VALUE;
+ }
+ bool has_int_value() const
+ {
+ return state == SHORT_DATA_VALUE &&
+ value.type_handler()->cmp_type() == INT_RESULT;
+ }
+ /*
+ This method is used to make a copy of a basic constant item when
+ propagating constants in the optimizer. The reason to create a new
+ item and not use the existing one is not precisely known (2005/04/16).
+ Probably we are trying to preserve tree structure of items, in other
+ words, avoid pointing at one item from two different nodes of the tree.
+ Return a new basic constant item if parameter value is a basic
+ constant, assert otherwise. This method is called only if
+ basic_const_item returned TRUE.
+ */
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override;
+ Item *clone_item(THD *thd) override;
+ void set_param_type_and_swap_value(Item_param *from);
+
+ Rewritable_query_parameter *get_rewritable_query_parameter() override
+ { return this; }
+ Settable_routine_parameter *get_settable_routine_parameter() override
+ { return m_is_settable_routine_parameter ? this : nullptr; }
+
+ bool append_for_log(THD *thd, String *str) override;
+ bool check_vcol_func_processor(void *) override { return false; }
+ Item *get_copy(THD *) override { return nullptr; }
+
+ bool add_as_clone(THD *thd);
+ void sync_clones();
+ bool register_clone(Item_param *i) { return m_clones.push_back(i); }
+
+private:
+ void invalid_default_param() const;
+
+ bool set_value(THD *thd, sp_rcontext *ctx, Item **it) override;
+
+ void set_out_param_info(Send_field *info) override;
+
+public:
+ const Send_field *get_out_param_info() const override;
+
+ Item_param *get_item_param() override { return this; }
+
+ void make_send_field(THD *thd, Send_field *field) override;
+
+private:
+ Send_field *m_out_param_info;
+ bool m_is_settable_routine_parameter;
+ /*
+ Array of all references of this parameter marker used in a CTE to its clones
+ created for copies of this marker used the CTE's copies. It's used to
+ synchronize the actual value of the parameter with the values of the clones.
+ */
+ Mem_root_array<Item_param *, true> m_clones;
+};
+
+
+class Item_int :public Item_num
+{
+public:
+ longlong value;
+ Item_int(THD *thd, int32 i,size_t length= MY_INT32_NUM_DECIMAL_DIGITS):
+ Item_num(thd), value((longlong) i)
+ { max_length=(uint32)length; }
+ Item_int(THD *thd, longlong i,size_t length= MY_INT64_NUM_DECIMAL_DIGITS):
+ Item_num(thd), value(i)
+ { max_length=(uint32)length; }
+ Item_int(THD *thd, ulonglong i, size_t length= MY_INT64_NUM_DECIMAL_DIGITS):
+ Item_num(thd), value((longlong)i)
+ { max_length=(uint32)length; unsigned_flag= 1; }
+ Item_int(THD *thd, const char *str_arg,longlong i,size_t length):
+ Item_num(thd), value(i)
+ {
+ max_length=(uint32)length;
+ name.str= str_arg; name.length= safe_strlen(name.str);
+ }
+ Item_int(THD *thd, const char *str_arg,longlong i,size_t length, bool flag):
+ Item_num(thd), value(i)
+ {
+ max_length=(uint32)length;
+ name.str= str_arg; name.length= safe_strlen(name.str);
+ unsigned_flag= flag;
+ }
+ Item_int(THD *thd, const char *str_arg, size_t length=64);
+ const Type_handler *type_handler() const override
+ { return type_handler_long_or_longlong(); }
+ Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table) override
+ { return tmp_table_field_from_field_type(root, table); }
+ const longlong *const_ptr_longlong() const override { return &value; }
+ longlong val_int() override { return value; }
+ longlong val_int_min() const override { return value; }
+ double val_real() override { return (double) value; }
+ my_decimal *val_decimal(my_decimal *) override;
+ String *val_str(String*) override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ bool is_order_clause_position() const override { return true; }
+ Item *clone_item(THD *thd) override;
+ void print(String *str, enum_query_type query_type) override;
+ Item *neg(THD *thd) override;
+ uint decimal_precision() const override
+ { return (uint) (max_length - MY_TEST(value < 0)); }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_int>(thd, this); }
+};
+
+
+/*
+ We sometimes need to distinguish a number from a boolean:
+ a[1] and a[true] are different things in XPath.
+ Also in JSON boolean values should be treated differently.
+*/
+class Item_bool :public Item_int
+{
+public:
+ Item_bool(THD *thd, const char *str_arg, longlong i):
+ Item_int(thd, str_arg, i, 1) {}
+ Item_bool(THD *thd, bool i) :Item_int(thd, (longlong) i, 1) { }
+ bool is_bool_literal() const override { return true; }
+ Item *neg_transformer(THD *thd) override;
+ const Type_handler *type_handler() const override
+ { return &type_handler_bool; }
+ const Type_handler *fixed_type_handler() const override
+ { return &type_handler_bool; }
+ void quick_fix_field() override
+ {
+ /*
+ We can get here when Item_bool is created instead of a constant
+ predicate at various condition optimization stages in sql_select.
+ */
+ }
+};
+
+
+class Item_uint :public Item_int
+{
+public:
+ Item_uint(THD *thd, const char *str_arg, size_t length);
+ Item_uint(THD *thd, ulonglong i): Item_int(thd, i, 10) {}
+ Item_uint(THD *thd, const char *str_arg, longlong i, uint length);
+ double val_real() { return ulonglong2double((ulonglong)value); }
+ Item *clone_item(THD *thd);
+ Item *neg(THD *thd);
+ uint decimal_precision() const { return max_length; }
+ Item *get_copy(THD *thd)
+ { return get_item_copy<Item_uint>(thd, this); }
+};
+
+
+class Item_datetime :public Item_int
+{
+protected:
+ MYSQL_TIME ltime;
+public:
+ Item_datetime(THD *thd): Item_int(thd, 0) { unsigned_flag=0; }
+ int save_in_field(Field *field, bool no_conversions) override;
+ longlong val_int() override;
+ double val_real() override { return (double)val_int(); }
+ void set(longlong packed, enum_mysql_timestamp_type ts_type);
+ bool get_date(THD *thd, MYSQL_TIME *to, date_mode_t fuzzydate) override
+ {
+ *to= ltime;
+ return false;
+ }
+};
+
+
+/* decimal (fixed point) constant */
+class Item_decimal :public Item_num
+{
+protected:
+ my_decimal decimal_value;
+public:
+ Item_decimal(THD *thd, const char *str_arg, size_t length,
+ CHARSET_INFO *charset);
+ Item_decimal(THD *thd, const char *str, const my_decimal *val_arg,
+ uint decimal_par, uint length);
+ Item_decimal(THD *thd, const my_decimal *value_par);
+ Item_decimal(THD *thd, longlong val, bool unsig);
+ Item_decimal(THD *thd, double val, int precision, int scale);
+ Item_decimal(THD *thd, const uchar *bin, int precision, int scale);
+
+ const Type_handler *type_handler() const override
+ { return &type_handler_newdecimal; }
+ longlong val_int() override
+ { return decimal_value.to_longlong(unsigned_flag); }
+ double val_real() override { return decimal_value.to_double(); }
+ String *val_str(String *to) override { return decimal_value.to_string(to); }
+ my_decimal *val_decimal(my_decimal *val) override { return &decimal_value; }
+ const my_decimal *const_ptr_my_decimal() const override
+ { return &decimal_value; }
+ int save_in_field(Field *field, bool no_conversions) override;
+ Item *clone_item(THD *thd) override;
+ void print(String *str, enum_query_type query_type) override
+ {
+ decimal_value.to_string(&str_value);
+ str->append(str_value);
+ }
+ Item *neg(THD *thd) override;
+ uint decimal_precision() const override { return decimal_value.precision(); }
+ void set_decimal_value(my_decimal *value_par);
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_decimal>(thd, this); }
+};
+
+
+class Item_float :public Item_num
+{
+ const char *presentation;
+public:
+ double value;
+ Item_float(THD *thd, const char *str_arg, size_t length);
+ Item_float(THD *thd, const char *str, double val_arg, uint decimal_par,
+ uint length): Item_num(thd), value(val_arg)
+ {
+ presentation= name.str= str;
+ name.length= safe_strlen(str);
+ decimals=(uint8) decimal_par;
+ max_length= length;
+ }
+ Item_float(THD *thd, double value_par, uint decimal_par):
+ Item_num(thd), presentation(0), value(value_par)
+ {
+ decimals= (uint8) decimal_par;
+ }
+ int save_in_field(Field *field, bool no_conversions) override;
+ const Type_handler *type_handler() const override
+ { return &type_handler_double; }
+ const double *const_ptr_double() const override { return &value; }
+ double val_real() override { return value; }
+ longlong val_int() override
+ {
+ if (value <= (double) LONGLONG_MIN)
+ {
+ return LONGLONG_MIN;
+ }
+ else if (value >= (double) (ulonglong) LONGLONG_MAX)
+ {
+ return LONGLONG_MAX;
+ }
+ return (longlong) rint(value);
+ }
+ String *val_str(String*) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ Item *clone_item(THD *thd) override;
+ Item *neg(THD *thd) override;
+ void print(String *str, enum_query_type query_type) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_float>(thd, this); }
+};
+
+
+class Item_static_float_func :public Item_float
+{
+ const char *func_name;
+public:
+ Item_static_float_func(THD *thd, const char *str, double val_arg,
+ uint decimal_par, uint length):
+ Item_float(thd, NullS, val_arg, decimal_par, length), func_name(str)
+ {}
+
+ void print(String *str, enum_query_type) override
+ {
+ str->append(func_name);
+ }
+
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override
+ {
+ return const_charset_converter(thd, tocs, true, func_name);
+ }
+};
+
+
+class Item_string :public Item_literal
+{
+protected:
+ void fix_from_value(Derivation dv, const Metadata metadata)
+ {
+ fix_charset_and_length(str_value.charset(), dv, metadata);
+ }
+ void fix_and_set_name_from_value(THD *thd, Derivation dv,
+ const Metadata metadata)
+ {
+ fix_from_value(dv, metadata);
+ set_name(thd, &str_value);
+ }
+protected:
+ /* Just create an item and do not fill string representation */
+ Item_string(THD *thd, CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE):
+ Item_literal(thd)
+ {
+ collation.set(cs, dv);
+ max_length= 0;
+ set_name(thd, NULL, 0, system_charset_info);
+ decimals= NOT_FIXED_DEC;
+ }
+public:
+ Item_string(THD *thd, CHARSET_INFO *csi, const char *str_arg, uint length_arg)
+ :Item_literal(thd)
+ {
+ collation.set(csi, DERIVATION_COERCIBLE);
+ set_name(thd, NULL, 0, system_charset_info);
+ decimals= NOT_FIXED_DEC;
+ str_value.copy(str_arg, length_arg, csi);
+ max_length= str_value.numchars() * csi->mbmaxlen;
+ }
+ // Constructors with the item name set from its value
+ Item_string(THD *thd, const char *str, uint length, CHARSET_INFO *cs,
+ Derivation dv, my_repertoire_t repertoire)
+ :Item_literal(thd)
+ {
+ str_value.set_or_copy_aligned(str, length, cs);
+ fix_and_set_name_from_value(thd, dv, Metadata(&str_value, repertoire));
+ }
+ Item_string(THD *thd, const char *str, size_t length,
+ CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
+ :Item_literal(thd)
+ {
+ str_value.set_or_copy_aligned(str, length, cs);
+ fix_and_set_name_from_value(thd, dv, Metadata(&str_value));
+ }
+ Item_string(THD *thd, const String *str, CHARSET_INFO *tocs, uint *conv_errors,
+ Derivation dv, my_repertoire_t repertoire)
+ :Item_literal(thd)
+ {
+ if (str_value.copy(str, tocs, conv_errors))
+ str_value.set("", 0, tocs); // EOM ?
+ str_value.mark_as_const();
+ fix_and_set_name_from_value(thd, dv, Metadata(&str_value, repertoire));
+ }
+ // Constructors with an externally provided item name
+ Item_string(THD *thd, const LEX_CSTRING &name_par, const LEX_CSTRING &str,
+ CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
+ :Item_literal(thd)
+ {
+ str_value.set_or_copy_aligned(str.str, str.length, cs);
+ fix_from_value(dv, Metadata(&str_value));
+ set_name(thd, name_par);
+ }
+ Item_string(THD *thd, const LEX_CSTRING &name_par, const LEX_CSTRING &str,
+ CHARSET_INFO *cs, Derivation dv, my_repertoire_t repertoire)
+ :Item_literal(thd)
+ {
+ str_value.set_or_copy_aligned(str.str, str.length, cs);
+ fix_from_value(dv, Metadata(&str_value, repertoire));
+ set_name(thd, name_par);
+ }
+ void print_value(String *to) const
+ {
+ str_value.print(to);
+ }
+ double val_real() override;
+ longlong val_int() override;
+ const String *const_ptr_string() const override { return &str_value; }
+ String *val_str(String*) override
+ {
+ return (String*) &str_value;
+ }
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ {
+ return get_date_from_string(thd, ltime, fuzzydate);
+ }
+ int save_in_field(Field *field, bool no_conversions) override;
+ const Type_handler *type_handler() const override
+ { return &type_handler_varchar; }
+ Item *clone_item(THD *thd) override;
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override
+ {
+ return const_charset_converter(thd, tocs, true);
+ }
+ inline void append(const char *str, uint length)
+ {
+ str_value.append(str, length);
+ max_length= str_value.numchars() * collation.collation->mbmaxlen;
+ }
+ void print(String *str, enum_query_type query_type) override;
+
+ /**
+ Return TRUE if character-set-introducer was explicitly specified in the
+ original query for this item (text literal).
+
+ This operation is to be called from Item_string::print(). The idea is
+ that when a query is generated (re-constructed) from the Item-tree,
+ character-set-introducers should appear only for those literals, where
+ they were explicitly specified by the user. Otherwise, that may lead to
+ loss collation information (character set introducers implies default
+ collation for the literal).
+
+ Basically, that makes sense only for views and hopefully will be gone
+ one day when we start using original query as a view definition.
+
+ @return This operation returns the value of m_cs_specified attribute.
+ @retval TRUE if character set introducer was explicitly specified in
+ the original query.
+ @retval FALSE otherwise.
+ */
+ virtual bool is_cs_specified() const
+ {
+ return false;
+ }
+
+ String *check_well_formed_result(bool send_error)
+ { return Item::check_well_formed_result(&str_value, send_error); }
+
+ Item_basic_constant *make_string_literal_concat(THD *thd,
+ const LEX_CSTRING *)
+ override;
+ Item *make_odbc_literal(THD *thd, const LEX_CSTRING *typestr) override;
+
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_string>(thd, this); }
+
+};
+
+
+class Item_string_with_introducer :public Item_string
+{
+public:
+ Item_string_with_introducer(THD *thd, const LEX_CSTRING &str,
+ CHARSET_INFO *cs):
+ Item_string(thd, str.str, str.length, cs)
+ { }
+ Item_string_with_introducer(THD *thd, const LEX_CSTRING &name_arg,
+ const LEX_CSTRING &str, CHARSET_INFO *tocs):
+ Item_string(thd, name_arg, str, tocs)
+ { }
+ virtual bool is_cs_specified() const
+ {
+ return true;
+ }
+};
+
+
+class Item_string_sys :public Item_string
+{
+public:
+ Item_string_sys(THD *thd, const char *str, uint length):
+ Item_string(thd, str, length, system_charset_info)
+ { }
+ Item_string_sys(THD *thd, const char *str):
+ Item_string(thd, str, (uint) strlen(str), system_charset_info)
+ { }
+};
+
+
+class Item_string_ascii :public Item_string
+{
+public:
+ Item_string_ascii(THD *thd, const char *str, uint length):
+ Item_string(thd, str, length, &my_charset_latin1,
+ DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII)
+ { }
+ Item_string_ascii(THD *thd, const char *str):
+ Item_string(thd, str, (uint) strlen(str), &my_charset_latin1,
+ DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII)
+ { }
+};
+
+
+class Item_static_string_func :public Item_string
+{
+ const LEX_CSTRING func_name;
+public:
+ Item_static_string_func(THD *thd, const LEX_CSTRING &name_par,
+ const LEX_CSTRING &str, CHARSET_INFO *cs,
+ Derivation dv= DERIVATION_COERCIBLE):
+ Item_string(thd, LEX_CSTRING({NullS,0}), str, cs, dv), func_name(name_par)
+ {}
+ Item_static_string_func(THD *thd, const LEX_CSTRING &name_par,
+ const String *str,
+ CHARSET_INFO *tocs, uint *conv_errors,
+ Derivation dv, my_repertoire_t repertoire):
+ Item_string(thd, str, tocs, conv_errors, dv, repertoire),
+ func_name(name_par)
+ {}
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override
+ {
+ return const_charset_converter(thd, tocs, true, func_name.str);
+ }
+
+ void print(String *str, enum_query_type) override
+ {
+ str->append(func_name);
+ }
+
+ bool check_partition_func_processor(void *) override { return true; }
+
+ bool check_vcol_func_processor(void *arg) override
+ { // VCOL_TIME_FUNC because the value is not constant, but does not
+ // require fix_fields() to be re-run for every statement.
+ return mark_unsupported_function(func_name.str, arg, VCOL_TIME_FUNC);
+ }
+};
+
+
+/* for show tables */
+class Item_partition_func_safe_string: public Item_string
+{
+public:
+ Item_partition_func_safe_string(THD *thd, const LEX_CSTRING &name_arg,
+ uint length, CHARSET_INFO *cs):
+ Item_string(thd, name_arg, LEX_CSTRING({0,0}), cs)
+ {
+ max_length= length;
+ }
+ bool check_vcol_func_processor(void *arg)
+ {
+ return mark_unsupported_function("safe_string", arg, VCOL_IMPOSSIBLE);
+ }
+};
+
+
+/**
+ Item_empty_string -- is a utility class to put an item into List<Item>
+ which is then used in protocol.send_result_set_metadata() when sending SHOW output to
+ the client.
+*/
+
+class Item_empty_string :public Item_partition_func_safe_string
+{
+public:
+ Item_empty_string(THD *thd, const LEX_CSTRING &header, uint length,
+ CHARSET_INFO *cs= &my_charset_utf8mb3_general_ci)
+ :Item_partition_func_safe_string(thd, header, length * cs->mbmaxlen, cs)
+ { }
+ Item_empty_string(THD *thd, const char *header, uint length,
+ CHARSET_INFO *cs= &my_charset_utf8mb3_general_ci)
+ :Item_partition_func_safe_string(thd, LEX_CSTRING({header, strlen(header)}),
+ length * cs->mbmaxlen, cs)
+ { }
+ void make_send_field(THD *thd, Send_field *field);
+};
+
+
+class Item_return_int :public Item_int
+{
+ enum_field_types int_field_type;
+public:
+ Item_return_int(THD *thd, const char *name_arg, uint length,
+ enum_field_types field_type_arg, longlong value_arg= 0):
+ Item_int(thd, name_arg, value_arg, length), int_field_type(field_type_arg)
+ {
+ unsigned_flag=1;
+ }
+ const Type_handler *type_handler() const
+ {
+ const Type_handler *h=
+ Type_handler::get_handler_by_field_type(int_field_type);
+ return unsigned_flag ? h->type_handler_unsigned() : h;
+ }
+};
+
+
+/**
+ Item_hex_constant -- a common class for hex literals: X'HHHH' and 0xHHHH
+*/
+class Item_hex_constant: public Item_literal
+{
+private:
+ void hex_string_init(THD *thd, const char *str, size_t str_length);
+public:
+ Item_hex_constant(THD *thd): Item_literal(thd)
+ {
+ hex_string_init(thd, "", 0);
+ }
+ Item_hex_constant(THD *thd, const char *str, size_t str_length):
+ Item_literal(thd)
+ {
+ hex_string_init(thd, str, str_length);
+ }
+ const Type_handler *type_handler() const { return &type_handler_varchar; }
+ virtual Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+ {
+ return const_charset_converter(thd, tocs, true);
+ }
+ const String *const_ptr_string() const { return &str_value; }
+ String *val_str(String*) { return &str_value; }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+ {
+ return type_handler()->Item_get_date_with_warn(thd, this, ltime, fuzzydate);
+ }
+};
+
+
+/**
+ Item_hex_hybrid -- is a class implementing 0xHHHH literals, e.g.:
+ SELECT 0x3132;
+ They can behave as numbers and as strings depending on context.
+*/
+class Item_hex_hybrid: public Item_hex_constant
+{
+public:
+ Item_hex_hybrid(THD *thd): Item_hex_constant(thd) {}
+ Item_hex_hybrid(THD *thd, const char *str, size_t str_length):
+ Item_hex_constant(thd, str, str_length) {}
+ const Type_handler *type_handler() const override
+ { return &type_handler_hex_hybrid; }
+ uint decimal_precision() const override;
+ double val_real() override
+ {
+ return (double) (ulonglong) Item_hex_hybrid::val_int();
+ }
+ longlong val_int() override
+ {
+ return longlong_from_hex_hybrid(str_value.ptr(), str_value.length());
+ }
+ my_decimal *val_decimal(my_decimal *decimal_value) override
+ {
+ longlong value= Item_hex_hybrid::val_int();
+ int2my_decimal(E_DEC_FATAL_ERROR, value, TRUE, decimal_value);
+ return decimal_value;
+ }
+ int save_in_field(Field *field, bool) override
+ {
+ field->set_notnull();
+ return field->store_hex_hybrid(str_value.ptr(), str_value.length());
+ }
+ void print(String *str, enum_query_type query_type) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_hex_hybrid>(thd, this); }
+};
+
+
+/**
+ Item_hex_string -- is a class implementing X'HHHH' literals, e.g.:
+ SELECT X'3132';
+ Unlike Item_hex_hybrid, X'HHHH' literals behave as strings in all contexts.
+ X'HHHH' are also used in replication of string constants in case of
+ "dangerous" charsets (sjis, cp932, big5, gbk) who can have backslash (0x5C)
+ as the second byte of a multi-byte character, so using '\' escaping for
+ these charsets is not desirable.
+*/
+class Item_hex_string: public Item_hex_constant
+{
+public:
+ Item_hex_string(THD *thd): Item_hex_constant(thd) {}
+ Item_hex_string(THD *thd, const char *str, size_t str_length):
+ Item_hex_constant(thd, str, str_length) {}
+ longlong val_int() override
+ {
+ return longlong_from_string_with_check(&str_value);
+ }
+ double val_real() override
+ {
+ return double_from_string_with_check(&str_value);
+ }
+ my_decimal *val_decimal(my_decimal *decimal_value) override
+ {
+ return val_decimal_from_string(decimal_value);
+ }
+ int save_in_field(Field *field, bool) override
+ {
+ field->set_notnull();
+ return field->store(str_value.ptr(), str_value.length(),
+ collation.collation);
+ }
+ void print(String *str, enum_query_type query_type) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_hex_string>(thd, this); }
+};
+
+
+class Item_bin_string: public Item_hex_hybrid
+{
+public:
+ Item_bin_string(THD *thd, const char *str, size_t str_length);
+};
+
+
+class Item_timestamp_literal: public Item_literal
+{
+ Timestamp_or_zero_datetime m_value;
+public:
+ Item_timestamp_literal(THD *thd)
+ :Item_literal(thd)
+ { }
+ const Type_handler *type_handler() const override
+ { return &type_handler_timestamp2; }
+ int save_in_field(Field *field, bool) override
+ {
+ Timestamp_or_zero_datetime_native native(m_value, decimals);
+ return native.save_in_field(field, decimals);
+ }
+ longlong val_int() override
+ {
+ return m_value.to_datetime(current_thd).to_longlong();
+ }
+ double val_real() override
+ {
+ return m_value.to_datetime(current_thd).to_double();
+ }
+ String *val_str(String *to) override
+ {
+ return m_value.to_datetime(current_thd).to_string(to, decimals);
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return m_value.to_datetime(current_thd).to_decimal(to);
+ }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ {
+ bool res= m_value.to_TIME(thd, ltime, fuzzydate);
+ DBUG_ASSERT(!res);
+ return res;
+ }
+ bool val_native(THD *thd, Native *to) override
+ {
+ return m_value.to_native(to, decimals);
+ }
+ void set_value(const Timestamp_or_zero_datetime &value)
+ {
+ m_value= value;
+ }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_timestamp_literal>(thd, this); }
+};
+
+
+class Item_temporal_literal :public Item_literal
+{
+public:
+ Item_temporal_literal(THD *thd)
+ :Item_literal(thd)
+ {
+ collation= DTCollation_numeric();
+ decimals= 0;
+ }
+ Item_temporal_literal(THD *thd, uint dec_arg):
+ Item_literal(thd)
+ {
+ collation= DTCollation_numeric();
+ decimals= dec_arg;
+ }
+
+ int save_in_field(Field *field, bool no_conversions) override
+ { return save_date_in_field(field, no_conversions); }
+};
+
+
+/**
+ DATE'2010-01-01'
+*/
+class Item_date_literal: public Item_temporal_literal
+{
+protected:
+ Date cached_time;
+ bool update_null()
+ {
+ return maybe_null &&
+ (null_value= cached_time.check_date_with_warn(current_thd));
+ }
+public:
+ Item_date_literal(THD *thd, const Date *ltime)
+ :Item_temporal_literal(thd),
+ cached_time(*ltime)
+ {
+ DBUG_ASSERT(cached_time.is_valid_date());
+ max_length= MAX_DATE_WIDTH;
+ /*
+ If date has zero month or day, it can return NULL in case of
+ NO_ZERO_DATE or NO_ZERO_IN_DATE.
+ If date is `February 30`, it can return NULL in case if
+ no ALLOW_INVALID_DATES is set.
+ We can't set null_value using the current sql_mode here in constructor,
+ because sql_mode can change in case of prepared statements
+ between PREPARE and EXECUTE.
+ Here we only set maybe_null to true if the value has such anomalies.
+ Later (during execution time), if maybe_null is true, then the value
+ will be checked per row, according to the execution time sql_mode.
+ The check_date() below call should cover all cases mentioned.
+ */
+ maybe_null= cached_time.check_date(TIME_NO_ZERO_DATE | TIME_NO_ZERO_IN_DATE);
+ }
+ const Type_handler *type_handler() const override
+ { return &type_handler_newdate; }
+ void print(String *str, enum_query_type query_type) override;
+ const MYSQL_TIME *const_ptr_mysql_time() const override
+ {
+ return cached_time.get_mysql_time();
+ }
+ Item *clone_item(THD *thd) override;
+ longlong val_int() override
+ {
+ return update_null() ? 0 : cached_time.to_longlong();
+ }
+ double val_real() override
+ {
+ return update_null() ? 0 : cached_time.to_double();
+ }
+ String *val_str(String *to) override
+ {
+ return update_null() ? 0 : cached_time.to_string(to);
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return update_null() ? 0 : cached_time.to_decimal(to);
+ }
+ longlong val_datetime_packed(THD *thd) override
+ {
+ return update_null() ? 0 : cached_time.valid_date_to_packed();
+ }
+ bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_date_literal>(thd, this); }
+};
+
+
+/**
+ TIME'10:10:10'
+*/
+class Item_time_literal: public Item_temporal_literal
+{
+protected:
+ Time cached_time;
+public:
+ Item_time_literal(THD *thd, const Time *ltime, uint dec_arg):
+ Item_temporal_literal(thd, dec_arg),
+ cached_time(*ltime)
+ {
+ DBUG_ASSERT(cached_time.is_valid_time());
+ max_length= MIN_TIME_WIDTH + (decimals ? decimals + 1 : 0);
+ }
+ const Type_handler *type_handler() const override
+ { return &type_handler_time2; }
+ void print(String *str, enum_query_type query_type) override;
+ const MYSQL_TIME *const_ptr_mysql_time() const override
+ {
+ return cached_time.get_mysql_time();
+ }
+ Item *clone_item(THD *thd) override;
+ longlong val_int() override { return cached_time.to_longlong(); }
+ double val_real() override { return cached_time.to_double(); }
+ String *val_str(String *to) override
+ { return cached_time.to_string(to, decimals); }
+ my_decimal *val_decimal(my_decimal *to) override
+ { return cached_time.to_decimal(to); }
+ longlong val_time_packed(THD *thd) override
+ {
+ return cached_time.valid_time_to_packed();
+ }
+ bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
+ bool val_native(THD *thd, Native *to) override
+ {
+ return Time(thd, this).to_native(to, decimals);
+ }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_time_literal>(thd, this); }
+};
+
+
+/**
+ TIMESTAMP'2001-01-01 10:20:30'
+*/
+class Item_datetime_literal: public Item_temporal_literal
+{
+protected:
+ Datetime cached_time;
+ bool update_null()
+ {
+ return maybe_null &&
+ (null_value= cached_time.check_date_with_warn(current_thd));
+ }
+public:
+ Item_datetime_literal(THD *thd, const Datetime *ltime, uint dec_arg):
+ Item_temporal_literal(thd, dec_arg),
+ cached_time(*ltime)
+ {
+ DBUG_ASSERT(cached_time.is_valid_datetime());
+ max_length= MAX_DATETIME_WIDTH + (decimals ? decimals + 1 : 0);
+ // See the comment on maybe_null in Item_date_literal
+ maybe_null= cached_time.check_date(TIME_NO_ZERO_DATE | TIME_NO_ZERO_IN_DATE);
+ }
+ const Type_handler *type_handler() const override
+ { return &type_handler_datetime2; }
+ void print(String *str, enum_query_type query_type) override;
+ const MYSQL_TIME *const_ptr_mysql_time() const override
+ {
+ return cached_time.get_mysql_time();
+ }
+ Item *clone_item(THD *thd) override;
+ longlong val_int() override
+ {
+ return update_null() ? 0 : cached_time.to_longlong();
+ }
+ double val_real() override
+ {
+ return update_null() ? 0 : cached_time.to_double();
+ }
+ String *val_str(String *to) override
+ {
+ return update_null() ? NULL : cached_time.to_string(to, decimals);
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return update_null() ? NULL : cached_time.to_decimal(to);
+ }
+ longlong val_datetime_packed(THD *thd) override
+ {
+ return update_null() ? 0 : cached_time.valid_datetime_to_packed();
+ }
+ bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_datetime_literal>(thd, this); }
+};
+
+
+/**
+ An error-safe counterpart for Item_date_literal
+*/
+class Item_date_literal_for_invalid_dates: public Item_date_literal
+{
+ /**
+ During equal field propagation we can replace non-temporal constants
+ found in equalities to their native temporal equivalents:
+ WHERE date_column='2001-01-01' ... ->
+ WHERE date_column=DATE'2001-01-01' ...
+
+ This is done to make the eqial field propagation code handle mixtures of
+ different temporal types in the same expressions easier (MDEV-8706), e.g.
+ WHERE LENGTH(date_column)=10 AND date_column=TIME'00:00:00'
+
+ Item_date_literal_for_invalid_dates::get_date()
+ (unlike the regular Item_date_literal::get_date())
+ does not check the result for NO_ZERO_IN_DATE and NO_ZERO_DATE,
+ always returns success (false), and does not produce error/warning messages.
+
+ We need these _for_invalid_dates classes to be able to rewrite:
+ SELECT * FROM t1 WHERE date_column='0000-00-00' ...
+ to:
+ SELECT * FROM t1 WHERE date_column=DATE'0000-00-00' ...
+
+ to avoid returning NULL value instead of '0000-00-00' even
+ in sql_mode=TRADITIONAL.
+ */
+public:
+ Item_date_literal_for_invalid_dates(THD *thd, const Date *ltime)
+ :Item_date_literal(thd, ltime)
+ {
+ maybe_null= false;
+ }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+ {
+ cached_time.copy_to_mysql_time(ltime);
+ return (null_value= false);
+ }
+};
+
+
+/**
+ An error-safe counterpart for Item_datetime_literal
+ (see Item_date_literal_for_invalid_dates for comments)
+*/
+class Item_datetime_literal_for_invalid_dates: public Item_datetime_literal
+{
+public:
+ Item_datetime_literal_for_invalid_dates(THD *thd,
+ const Datetime *ltime, uint dec_arg)
+ :Item_datetime_literal(thd, ltime, dec_arg)
+ {
+ maybe_null= false;
+ }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+ {
+ cached_time.copy_to_mysql_time(ltime);
+ return (null_value= false);
+ }
+};
+
+
+class Used_tables_and_const_cache
+{
+public:
+ /*
+ In some cases used_tables_cache is not what used_tables() return
+ so the method should be used where one need used tables bit map
+ (even internally in Item_func_* code).
+ */
+ table_map used_tables_cache;
+ bool const_item_cache;
+
+ Used_tables_and_const_cache()
+ :used_tables_cache(0),
+ const_item_cache(true)
+ { }
+ Used_tables_and_const_cache(const Used_tables_and_const_cache *other)
+ :used_tables_cache(other->used_tables_cache),
+ const_item_cache(other->const_item_cache)
+ { }
+ void used_tables_and_const_cache_init()
+ {
+ used_tables_cache= 0;
+ const_item_cache= true;
+ }
+ void used_tables_and_const_cache_join(const Item *item)
+ {
+ used_tables_cache|= item->used_tables();
+ const_item_cache&= item->const_item();
+ }
+ void used_tables_and_const_cache_update_and_join(Item *item)
+ {
+ item->update_used_tables();
+ used_tables_and_const_cache_join(item);
+ }
+ /*
+ Call update_used_tables() for all "argc" items in the array "argv"
+ and join with the current cache.
+ "this" must be initialized with a constructor or
+ re-initialized with used_tables_and_const_cache_init().
+ */
+ void used_tables_and_const_cache_update_and_join(uint argc, Item **argv)
+ {
+ for (uint i=0 ; i < argc ; i++)
+ used_tables_and_const_cache_update_and_join(argv[i]);
+ }
+ /*
+ Call update_used_tables() for all items in the list
+ and join with the current cache.
+ "this" must be initialized with a constructor or
+ re-initialized with used_tables_and_const_cache_init().
+ */
+ void used_tables_and_const_cache_update_and_join(List<Item> &list)
+ {
+ List_iterator_fast<Item> li(list);
+ Item *item;
+ while ((item=li++))
+ used_tables_and_const_cache_update_and_join(item);
+ }
+};
+
+
+/**
+ An abstract class representing common features of
+ regular functions and aggregate functions.
+*/
+class Item_func_or_sum: public Item_result_field,
+ public Item_args,
+ public Used_tables_and_const_cache,
+ public With_subquery_cache
+{
+protected:
+ bool agg_arg_charsets(DTCollation &c, Item **items, uint nitems,
+ uint flags, int item_sep)
+ {
+ return Type_std_attributes::agg_arg_charsets(c, func_name(),
+ items, nitems,
+ flags, item_sep);
+ }
+ bool agg_arg_charsets_for_string_result(DTCollation &c,
+ Item **items, uint nitems,
+ int item_sep= 1)
+ {
+ return Type_std_attributes::
+ agg_arg_charsets_for_string_result(c, func_name(),
+ items, nitems, item_sep);
+ }
+ bool agg_arg_charsets_for_string_result_with_comparison(DTCollation &c,
+ Item **items,
+ uint nitems,
+ int item_sep= 1)
+ {
+ return Type_std_attributes::
+ agg_arg_charsets_for_string_result_with_comparison(c, func_name(),
+ items, nitems,
+ item_sep);
+ }
+
+ /*
+ Aggregate arguments for comparison, e.g: a=b, a LIKE b, a RLIKE b
+ - don't convert to @@character_set_connection if all arguments are numbers
+ - don't allow DERIVATION_NONE
+ */
+ bool agg_arg_charsets_for_comparison(DTCollation &c,
+ Item **items, uint nitems,
+ int item_sep= 1)
+ {
+ return Type_std_attributes::
+ agg_arg_charsets_for_comparison(c, func_name(), items, nitems, item_sep);
+ }
+
+public:
+ // This method is used by Arg_comparator
+ bool agg_arg_charsets_for_comparison(CHARSET_INFO **cs, Item **a, Item **b)
+ {
+ DTCollation tmp;
+ if (tmp.set((*a)->collation, (*b)->collation, MY_COLL_CMP_CONV) ||
+ tmp.derivation == DERIVATION_NONE)
+ {
+ my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
+ (*a)->collation.collation->name,
+ (*a)->collation.derivation_name(),
+ (*b)->collation.collation->name,
+ (*b)->collation.derivation_name(),
+ func_name());
+ return true;
+ }
+ if (agg_item_set_converter(tmp, func_name(),
+ a, 1, MY_COLL_CMP_CONV, 1) ||
+ agg_item_set_converter(tmp, func_name(),
+ b, 1, MY_COLL_CMP_CONV, 1))
+ return true;
+ *cs= tmp.collation;
+ return false;
+ }
+
+public:
+ Item_func_or_sum(THD *thd): Item_result_field(thd), Item_args() {}
+ Item_func_or_sum(THD *thd, Item *a): Item_result_field(thd), Item_args(a) { }
+ Item_func_or_sum(THD *thd, Item *a, Item *b):
+ Item_result_field(thd), Item_args(a, b) { }
+ Item_func_or_sum(THD *thd, Item *a, Item *b, Item *c):
+ Item_result_field(thd), Item_args(thd, a, b, c) { }
+ Item_func_or_sum(THD *thd, Item *a, Item *b, Item *c, Item *d):
+ Item_result_field(thd), Item_args(thd, a, b, c, d) { }
+ Item_func_or_sum(THD *thd, Item *a, Item *b, Item *c, Item *d, Item *e):
+ Item_result_field(thd), Item_args(thd, a, b, c, d, e) { }
+ Item_func_or_sum(THD *thd, Item_func_or_sum *item):
+ Item_result_field(thd, item), Item_args(thd, item),
+ Used_tables_and_const_cache(item) { }
+ Item_func_or_sum(THD *thd, List<Item> &list):
+ Item_result_field(thd), Item_args(thd, list) { }
+ bool with_subquery() const override
+ { DBUG_ASSERT(fixed); return m_with_subquery; }
+ bool walk(Item_processor processor, bool walk_subquery, void *arg) override
+ {
+ if (walk_args(processor, walk_subquery, arg))
+ return true;
+ return (this->*processor)(arg);
+ }
+ /*
+ This method is used for debug purposes to print the name of an
+ item to the debug log. The second use of this method is as
+ a helper function of print() and error messages, where it is
+ applicable. To suit both goals it should return a meaningful,
+ distinguishable and sintactically correct string. This method
+ should not be used for runtime type identification, use enum
+ {Sum}Functype and Item_func::functype()/Item_sum::sum_func()
+ instead.
+ Added here, to the parent class of both Item_func and Item_sum.
+
+ NOTE: for Items inherited from Item_sum, func_name() return part of
+ function name till first argument (including '(') to make difference in
+ names for functions with 'distinct' clause and without 'distinct' and
+ also to make printing of items inherited from Item_sum uniform.
+ */
+ virtual const char *func_name() const= 0;
+ virtual bool fix_length_and_dec()= 0;
+ bool const_item() const override { return const_item_cache; }
+ table_map used_tables() const override { return used_tables_cache; }
+ Item* build_clone(THD *thd) override;
+ Sql_mode_dependency value_depends_on_sql_mode() const override
+ {
+ return Item_args::value_depends_on_sql_mode_bit_or().soft_to_hard();
+ }
+};
+
+class sp_head;
+class sp_name;
+struct st_sp_security_context;
+
+class Item_sp
+{
+protected:
+ // Can be NULL in some non-SELECT queries
+ Name_resolution_context *context;
+public:
+ sp_name *m_name;
+ sp_head *m_sp;
+ TABLE *dummy_table;
+ uchar result_buf[64];
+ sp_rcontext *func_ctx;
+ MEM_ROOT sp_mem_root;
+ Query_arena *sp_query_arena;
+
+ /*
+ The result field of the stored function.
+ */
+ Field *sp_result_field;
+ Item_sp(THD *thd, Name_resolution_context *context_arg, sp_name *name_arg);
+ Item_sp(THD *thd, Item_sp *item);
+ const char *func_name(THD *thd) const;
+ void cleanup();
+ bool sp_check_access(THD *thd);
+ bool execute(THD *thd, bool *null_value, Item **args, uint arg_count);
+ bool execute_impl(THD *thd, Item **args, uint arg_count);
+ bool init_result_field(THD *thd, uint max_length, uint maybe_null,
+ bool *null_value, LEX_CSTRING *name);
+ void process_error(THD *thd)
+ {
+ if (context)
+ context->process_error(thd);
+ }
+};
+
+class Item_ref :public Item_ident,
+ protected With_sum_func_cache
+{
+protected:
+ void set_properties();
+ bool set_properties_only; // the item doesn't need full fix_fields
+public:
+ enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF, AGGREGATE_REF };
+ Item **ref;
+ bool reference_trough_name;
+ Item_ref(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &db_arg, const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg):
+ Item_ident(thd, context_arg, db_arg, table_name_arg, field_name_arg),
+ set_properties_only(0), ref(0), reference_trough_name(1) {}
+ Item_ref(THD *thd, Name_resolution_context *context_arg,
+ const LEX_CSTRING &field_name_arg)
+ :Item_ref(thd, context_arg, null_clex_str, null_clex_str, field_name_arg)
+ { }
+ /*
+ This constructor is used in two scenarios:
+ A) *item = NULL
+ No initialization is performed, fix_fields() call will be necessary.
+
+ B) *item points to an Item this Item_ref will refer to. This is
+ used for GROUP BY. fix_fields() will not be called in this case,
+ so we call set_properties to make this item "fixed". set_properties
+ performs a subset of action Item_ref::fix_fields does, and this subset
+ is enough for Item_ref's used in GROUP BY.
+
+ TODO we probably fix a superset of problems like in BUG#6658. Check this
+ with Bar, and if we have a more broader set of problems like this.
+ */
+ Item_ref(THD *thd, Name_resolution_context *context_arg, Item **item,
+ const LEX_CSTRING &table_name_arg, const LEX_CSTRING &field_name_arg,
+ bool alias_name_used_arg= FALSE);
+ Item_ref(THD *thd, TABLE_LIST *view_arg, Item **item,
+ const LEX_CSTRING &field_name_arg, bool alias_name_used_arg= FALSE);
+
+ /* Constructor need to process subselect with temporary tables (see Item) */
+ Item_ref(THD *thd, Item_ref *item)
+ :Item_ident(thd, item), With_sum_func_cache(*item),
+ set_properties_only(0), ref(item->ref) {}
+ Type type() const override { return REF_ITEM; }
+ Type real_type() const override
+ { return ref ? (*ref)->type() : REF_ITEM; }
+ bool eq(const Item *item, bool binary_cmp) const override
+ {
+ Item *it= ((Item *) item)->real_item();
+ return ref && (*ref)->eq(it, binary_cmp);
+ }
+ void save_val(Field *to) override;
+ void save_result(Field *to) override;
+ double val_real() override;
+ longlong val_int() override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool val_bool() override;
+ String *val_str(String* tmp) override;
+ bool val_native(THD *thd, Native *to) override;
+ bool is_null() override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ longlong val_datetime_packed(THD *) override;
+ longlong val_time_packed(THD *) override;
+ double val_result() override;
+ longlong val_int_result() override;
+ String *str_result(String* tmp) override;
+ bool val_native_result(THD *thd, Native *to) override;
+ my_decimal *val_decimal_result(my_decimal *) override;
+ bool val_bool_result() override;
+ bool is_null_result() override;
+ bool send(Protocol *prot, st_value *buffer) override;
+ void make_send_field(THD *thd, Send_field *field) override;
+ bool fix_fields(THD *, Item **) override;
+ void fix_after_pullout(st_select_lex *new_parent, Item **ref, bool merge)
+ override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ void save_org_in_field(Field *field, fast_field_copier optimizer_data)
+ override;
+ fast_field_copier setup_fast_field_copier(Field *field) override
+ { return (*ref)->setup_fast_field_copier(field); }
+ const Type_handler *type_handler() const override
+ { return (*ref)->type_handler(); }
+ const Type_handler *real_type_handler() const override
+ { return (*ref)->real_type_handler(); }
+ Field *get_tmp_table_field() override
+ { return result_field ? result_field : (*ref)->get_tmp_table_field(); }
+ Item *get_tmp_table_item(THD *thd) override;
+ Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override;
+ Item* propagate_equal_fields(THD *, const Context &, COND_EQUAL *) override;
+ table_map used_tables() const override;
+ void update_used_tables() override;
+ COND *build_equal_items(THD *thd, COND_EQUAL *inherited,
+ bool link_item_fields,
+ COND_EQUAL **cond_equal_ref) override
+ {
+ /*
+ normilize_cond() replaced all conditions of type
+ WHERE/HAVING field
+ to:
+ WHERE/HAVING field<>0
+ By the time of a build_equal_items() call, all such conditions should
+ already be replaced. No Item_ref referencing to Item_field are possible.
+ */
+ DBUG_ASSERT(real_type() != FIELD_ITEM);
+ return Item_ident::build_equal_items(thd, inherited, link_item_fields,
+ cond_equal_ref);
+ }
+ bool const_item() const override { return (*ref)->const_item(); }
+ table_map not_null_tables() const override
+ {
+ return depended_from ? 0 : (*ref)->not_null_tables();
+ }
+ bool find_not_null_fields(table_map allowed) override
+ {
+ return depended_from ? false : (*ref)->find_not_null_fields(allowed);
+ }
+ void save_in_result_field(bool no_conversions) override
+ {
+ (*ref)->save_in_field(result_field, no_conversions);
+ }
+ Item *real_item() override { return ref ? (*ref)->real_item() : this; }
+ const TYPELIB *get_typelib() const override
+ {
+ return ref ? (*ref)->get_typelib() : NULL;
+ }
+ bool is_json_type() override { return (*ref)->is_json_type(); }
+
+ bool walk(Item_processor processor, bool walk_subquery, void *arg) override
+ {
+ if (ref && *ref)
+ return (*ref)->walk(processor, walk_subquery, arg) ||
+ (this->*processor)(arg);
+ else
+ return FALSE;
+ }
+ Item* transform(THD *thd, Item_transformer, uchar *arg) override;
+ Item* compile(THD *thd, Item_analyzer analyzer, uchar **arg_p,
+ Item_transformer transformer, uchar *arg_t) override;
+ bool enumerate_field_refs_processor(void *arg) override
+ { return (*ref)->enumerate_field_refs_processor(arg); }
+ void no_rows_in_result() override
+ {
+ (*ref)->no_rows_in_result();
+ }
+ void restore_to_before_no_rows_in_result() override
+ {
+ (*ref)->restore_to_before_no_rows_in_result();
+ }
+ void print(String *str, enum_query_type query_type) override;
+ enum precedence precedence() const override
+ {
+ return ref ? (*ref)->precedence() : DEFAULT_PRECEDENCE;
+ }
+ void cleanup() override;
+ Item_field *field_for_view_update() override
+ { return (*ref)->field_for_view_update(); }
+ Load_data_outvar *get_load_data_outvar() override
+ {
+ return (*ref)->get_load_data_outvar();
+ }
+ virtual Ref_Type ref_type() { return REF; }
+
+ // Row emulation: forwarding of ROW-related calls to ref
+ uint cols() const override
+ {
+ return ref && result_type() == ROW_RESULT ? (*ref)->cols() : 1;
+ }
+ Item* element_index(uint i) override
+ {
+ return ref && result_type() == ROW_RESULT ? (*ref)->element_index(i) : this;
+ }
+ Item** addr(uint i) override
+ {
+ return ref && result_type() == ROW_RESULT ? (*ref)->addr(i) : 0;
+ }
+ bool check_cols(uint c) override
+ {
+ return ref && result_type() == ROW_RESULT ? (*ref)->check_cols(c)
+ : Item::check_cols(c);
+ }
+ bool null_inside() override
+ {
+ return ref && result_type() == ROW_RESULT ? (*ref)->null_inside() : 0;
+ }
+ void bring_value() override
+ {
+ if (ref && result_type() == ROW_RESULT)
+ (*ref)->bring_value();
+ }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function("ref", arg, VCOL_IMPOSSIBLE);
+ }
+ bool basic_const_item() const override
+ { return ref && (*ref)->basic_const_item(); }
+ bool is_outer_field() const override
+ {
+ DBUG_ASSERT(fixed);
+ DBUG_ASSERT(ref);
+ return (*ref)->is_outer_field();
+ }
+
+ Item* build_clone(THD *thd) override;
+
+ /**
+ Checks if the item tree that ref points to contains a subquery.
+ */
+ bool with_subquery() const override { return (*ref)->with_subquery(); }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_ref>(thd, this); }
+ bool excl_dep_on_table(table_map tab_map) override
+ {
+ table_map used= used_tables();
+ if (used & OUTER_REF_TABLE_BIT)
+ return false;
+ return (used == tab_map) || (*ref)->excl_dep_on_table(tab_map);
+ }
+ bool excl_dep_on_grouping_fields(st_select_lex *sel) override
+ { return (*ref)->excl_dep_on_grouping_fields(sel); }
+ bool excl_dep_on_in_subq_left_part(Item_in_subselect *subq_pred) override
+ { return (*ref)->excl_dep_on_in_subq_left_part(subq_pred); }
+ bool cleanup_excluding_fields_processor(void *arg) override
+ {
+ Item *item= real_item();
+ if (item && item->type() == FIELD_ITEM &&
+ ((Item_field *)item)->field)
+ return 0;
+ return cleanup_processor(arg);
+ }
+ bool cleanup_excluding_const_fields_processor(void *arg) override
+ {
+ Item *item= real_item();
+ if (item && item->type() == FIELD_ITEM &&
+ ((Item_field *) item)->field && item->const_item())
+ return 0;
+ return cleanup_processor(arg);
+ }
+ bool with_sum_func() const override { return m_with_sum_func; }
+ With_sum_func_cache* get_with_sum_func_cache() override { return this; }
+ Item *field_transformer_for_having_pushdown(THD *thd, uchar *arg) override
+ { return (*ref)->field_transformer_for_having_pushdown(thd, arg); }
+ Item *remove_item_direct_ref() override
+ {
+ *ref= (*ref)->remove_item_direct_ref();
+ return this;
+ }
+};
+
+
+/*
+ The same as Item_ref, but get value from val_* family of method to get
+ value of item on which it referred instead of result* family.
+*/
+class Item_direct_ref :public Item_ref
+{
+public:
+ Item_direct_ref(THD *thd, Name_resolution_context *context_arg, Item **item,
+ const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg,
+ bool alias_name_used_arg= FALSE):
+ Item_ref(thd, context_arg, item, table_name_arg,
+ field_name_arg, alias_name_used_arg)
+ {}
+ /* Constructor need to process subselect with temporary tables (see Item) */
+ Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {}
+ Item_direct_ref(THD *thd, TABLE_LIST *view_arg, Item **item,
+ const LEX_CSTRING &field_name_arg,
+ bool alias_name_used_arg= FALSE):
+ Item_ref(thd, view_arg, item, field_name_arg,
+ alias_name_used_arg)
+ {}
+
+ bool fix_fields(THD *thd, Item **it) override
+ {
+ if ((*ref)->fix_fields_if_needed_for_scalar(thd, ref))
+ return TRUE;
+ return Item_ref::fix_fields(thd, it);
+ }
+ void save_val(Field *to) override;
+ /* Below we should have all val() methods as in Item_ref */
+ double val_real() override;
+ longlong val_int() override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool val_bool() override;
+ String *val_str(String* tmp) override;
+ bool val_native(THD *thd, Native *to) override;
+ bool is_null() override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ longlong val_datetime_packed(THD *) override;
+ longlong val_time_packed(THD *) override;
+ Ref_Type ref_type() override { return DIRECT_REF; }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_direct_ref>(thd, this); }
+ Item *remove_item_direct_ref() override
+ { return (*ref)->remove_item_direct_ref(); }
+};
+
+
+/**
+ This class is the same as Item_direct_ref but created to wrap Item_ident
+ before fix_fields() call
+*/
+
+class Item_direct_ref_to_ident :public Item_direct_ref
+{
+ Item_ident *ident;
+public:
+ Item_direct_ref_to_ident(THD *thd, Item_ident *item):
+ Item_direct_ref(thd, item->context, (Item**)&item, item->table_name,
+ item->field_name, FALSE)
+ {
+ ident= item;
+ ref= (Item**)&ident;
+ }
+
+ bool fix_fields(THD *thd, Item **it) override
+ {
+ DBUG_ASSERT(ident->type() == FIELD_ITEM || ident->type() == REF_ITEM);
+ if (ident->fix_fields_if_needed_for_scalar(thd, ref))
+ return TRUE;
+ set_properties();
+ return FALSE;
+ }
+
+ void print(String *str, enum_query_type query_type) override
+ { ident->print(str, query_type); }
+
+};
+
+
+class Item_cache;
+class Expression_cache;
+class Expression_cache_tracker;
+
+/**
+ The objects of this class can store its values in an expression cache.
+*/
+
+class Item_cache_wrapper :public Item_result_field,
+ public With_subquery_cache,
+ protected With_sum_func_cache
+{
+private:
+ /* Pointer on the cached expression */
+ Item *orig_item;
+ Expression_cache *expr_cache;
+ /*
+ In order to put the expression into the expression cache and return
+ value of val_*() method, we will need to get the expression value twice
+ (probably in different types). In order to avoid making two
+ (potentially costly) orig_item->val_*() calls, we store expression value
+ in this Item_cache object.
+ */
+ Item_cache *expr_value;
+
+ List<Item> parameters;
+
+ Item *check_cache();
+ void cache();
+ void init_on_demand();
+
+public:
+ Item_cache_wrapper(THD *thd, Item *item_arg);
+ ~Item_cache_wrapper();
+
+ Type type() const override { return EXPR_CACHE_ITEM; }
+ Type real_type() const override { return orig_item->type(); }
+ bool with_subquery() const override
+ { DBUG_ASSERT(fixed); return m_with_subquery; }
+ bool with_sum_func() const override { return m_with_sum_func; }
+ With_sum_func_cache* get_with_sum_func_cache() override { return this; }
+
+ bool set_cache(THD *thd);
+ Expression_cache_tracker* init_tracker(MEM_ROOT *mem_root);
+
+ bool fix_fields(THD *thd, Item **it) override;
+ void cleanup() override;
+
+ Item *get_orig_item() const { return orig_item; }
+
+ /* Methods of getting value which should be cached in the cache */
+ void save_val(Field *to) override;
+ double val_real() override;
+ longlong val_int() override;
+ String *val_str(String* tmp) override;
+ bool val_native(THD *thd, Native *to) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool val_bool() override;
+ bool is_null() override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ bool send(Protocol *protocol, st_value *buffer) override;
+ void save_org_in_field(Field *field, fast_field_copier) override
+ {
+ save_val(field);
+ }
+ void save_in_result_field(bool) override { save_val(result_field); }
+ Item* get_tmp_table_item(THD *thd_arg) override;
+
+ /* Following methods make this item transparent as much as possible */
+
+ void print(String *str, enum_query_type query_type) override;
+ const char *full_name() const override { return orig_item->full_name(); }
+ void make_send_field(THD *thd, Send_field *field) override
+ { orig_item->make_send_field(thd, field); }
+ bool eq(const Item *item, bool binary_cmp) const override
+ {
+ Item *it= const_cast<Item*>(item)->real_item();
+ return orig_item->eq(it, binary_cmp);
+ }
+ void fix_after_pullout(st_select_lex *new_parent, Item **refptr, bool merge)
+ override
+ {
+ orig_item->fix_after_pullout(new_parent, &orig_item, merge);
+ }
+ int save_in_field(Field *to, bool no_conversions) override;
+ const Type_handler *type_handler() const override
+ { return orig_item->type_handler(); }
+ table_map used_tables() const override { return orig_item->used_tables(); }
+ void update_used_tables() override { orig_item->update_used_tables(); }
+ bool const_item() const override { return orig_item->const_item(); }
+ table_map not_null_tables() const override
+ { return orig_item->not_null_tables(); }
+ bool walk(Item_processor processor, bool walk_subquery, void *arg) override
+ {
+ return orig_item->walk(processor, walk_subquery, arg) ||
+ (this->*processor)(arg);
+ }
+ bool enumerate_field_refs_processor(void *arg) override
+ { return orig_item->enumerate_field_refs_processor(arg); }
+ Item_field *field_for_view_update() override
+ { return orig_item->field_for_view_update(); }
+
+ /* Row emulation: forwarding of ROW-related calls to orig_item */
+ uint cols() const override
+ { return result_type() == ROW_RESULT ? orig_item->cols() : 1; }
+ Item* element_index(uint i) override
+ { return result_type() == ROW_RESULT ? orig_item->element_index(i) : this; }
+ Item** addr(uint i) override
+ { return result_type() == ROW_RESULT ? orig_item->addr(i) : 0; }
+ bool check_cols(uint c) override
+ {
+ return (result_type() == ROW_RESULT ?
+ orig_item->check_cols(c) :
+ Item::check_cols(c));
+ }
+ bool null_inside() override
+ { return result_type() == ROW_RESULT ? orig_item->null_inside() : 0; }
+ void bring_value() override
+ {
+ if (result_type() == ROW_RESULT)
+ orig_item->bring_value();
+ }
+ bool is_expensive() override { return orig_item->is_expensive(); }
+ bool is_expensive_processor(void *arg) override
+ { return orig_item->is_expensive_processor(arg); }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function("cache", arg, VCOL_IMPOSSIBLE);
+ }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_wrapper>(thd, this); }
+ Item *build_clone(THD *) override { return nullptr; }
+};
+
+
+/*
+ Class for view fields, the same as Item_direct_ref, but call fix_fields
+ of reference if it is not called yet
+*/
+class Item_direct_view_ref :public Item_direct_ref
+{
+ Item_equal *item_equal;
+ TABLE_LIST *view;
+ TABLE *null_ref_table;
+
+#define NO_NULL_TABLE (reinterpret_cast<TABLE *>(0x1))
+
+ void set_null_ref_table()
+ {
+ if (!view->is_inner_table_of_outer_join() ||
+ !(null_ref_table= view->get_real_join_table()))
+ null_ref_table= NO_NULL_TABLE;
+ }
+
+ bool check_null_ref()
+ {
+ DBUG_ASSERT(null_ref_table);
+ if (null_ref_table != NO_NULL_TABLE && null_ref_table->null_row)
+ {
+ null_value= 1;
+ return TRUE;
+ }
+ return FALSE;
+ }
+
+public:
+ Item_direct_view_ref(THD *thd, Name_resolution_context *context_arg,
+ Item **item,
+ LEX_CSTRING &table_name_arg,
+ LEX_CSTRING &field_name_arg,
+ TABLE_LIST *view_arg):
+ Item_direct_ref(thd, context_arg, item, table_name_arg, field_name_arg),
+ item_equal(0), view(view_arg),
+ null_ref_table(NULL)
+ {
+ if (fixed)
+ set_null_ref_table();
+ }
+
+ bool fix_fields(THD *, Item **) override;
+ bool eq(const Item *item, bool binary_cmp) const override;
+ Item *get_tmp_table_item(THD *thd) override
+ {
+ if (const_item())
+ return copy_or_same(thd);
+ Item *item= Item_ref::get_tmp_table_item(thd);
+ item->name= name;
+ return item;
+ }
+ Ref_Type ref_type() override { return VIEW_REF; }
+ Item_equal *get_item_equal() override { return item_equal; }
+ void set_item_equal(Item_equal *item_eq) override { item_equal= item_eq; }
+ Item_equal *find_item_equal(COND_EQUAL *cond_equal) override;
+ Item* propagate_equal_fields(THD *, const Context &, COND_EQUAL *) override;
+ Item *replace_equal_field(THD *thd, uchar *arg) override;
+ table_map used_tables() const override;
+ void update_used_tables() override;
+ table_map not_null_tables() const override;
+ bool const_item() const override
+ {
+ return (*ref)->const_item() && (null_ref_table == NO_NULL_TABLE);
+ }
+ TABLE *get_null_ref_table() const { return null_ref_table; }
+ bool walk(Item_processor processor, bool walk_subquery, void *arg) override
+ {
+ return (*ref)->walk(processor, walk_subquery, arg) ||
+ (this->*processor)(arg);
+ }
+ bool view_used_tables_processor(void *arg) override
+ {
+ TABLE_LIST *view_arg= (TABLE_LIST *) arg;
+ if (view_arg == view)
+ view_arg->view_used_tables|= (*ref)->used_tables();
+ return 0;
+ }
+ bool excl_dep_on_table(table_map tab_map) override;
+ bool excl_dep_on_grouping_fields(st_select_lex *sel) override;
+ bool excl_dep_on_in_subq_left_part(Item_in_subselect *subq_pred) override;
+ Item *derived_field_transformer_for_having(THD *thd, uchar *arg) override;
+ Item *derived_field_transformer_for_where(THD *thd, uchar *arg) override;
+ Item *grouping_field_transformer_for_where(THD *thd, uchar *arg) override;
+ Item *in_subq_field_transformer_for_where(THD *thd, uchar *arg) override;
+ Item *in_subq_field_transformer_for_having(THD *thd, uchar *arg) override;
+
+ void save_val(Field *to) override
+ {
+ if (check_null_ref())
+ to->set_null();
+ else
+ Item_direct_ref::save_val(to);
+ }
+ double val_real() override
+ {
+ if (check_null_ref())
+ return 0;
+ else
+ return Item_direct_ref::val_real();
+ }
+ longlong val_int() override
+ {
+ if (check_null_ref())
+ return 0;
+ else
+ return Item_direct_ref::val_int();
+ }
+ String *val_str(String* tmp) override
+ {
+ if (check_null_ref())
+ return NULL;
+ else
+ return Item_direct_ref::val_str(tmp);
+ }
+ bool val_native(THD *thd, Native *to) override
+ {
+ if (check_null_ref())
+ return true;
+ return Item_direct_ref::val_native(thd, to);
+ }
+ my_decimal *val_decimal(my_decimal *tmp) override
+ {
+ if (check_null_ref())
+ return NULL;
+ else
+ return Item_direct_ref::val_decimal(tmp);
+ }
+ bool val_bool() override
+ {
+ if (check_null_ref())
+ return 0;
+ else
+ return Item_direct_ref::val_bool();
+ }
+ bool is_null() override
+ {
+ if (check_null_ref())
+ return 1;
+ else
+ return Item_direct_ref::is_null();
+ }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ {
+ if (check_null_ref())
+ {
+ bzero((char*) ltime,sizeof(*ltime));
+ return 1;
+ }
+ return Item_direct_ref::get_date(thd, ltime, fuzzydate);
+ }
+ longlong val_time_packed(THD *thd) override
+ {
+ if (check_null_ref())
+ return 0;
+ else
+ return Item_direct_ref::val_time_packed(thd);
+ }
+ longlong val_datetime_packed(THD *thd) override
+ {
+ if (check_null_ref())
+ return 0;
+ else
+ return Item_direct_ref::val_datetime_packed(thd);
+ }
+ bool send(Protocol *protocol, st_value *buffer) override;
+ void save_org_in_field(Field *field, fast_field_copier) override
+ {
+ if (check_null_ref())
+ field->set_null();
+ else
+ Item_direct_ref::save_val(field);
+ }
+ void save_in_result_field(bool no_conversions) override
+ {
+ if (check_null_ref())
+ result_field->set_null();
+ else
+ Item_direct_ref::save_in_result_field(no_conversions);
+ }
+
+ void cleanup() override
+ {
+ null_ref_table= NULL;
+ item_equal= NULL;
+ Item_direct_ref::cleanup();
+ }
+ /*
+ TODO move these val_*_result function to Item_direct_ref (maybe)
+ */
+ double val_result() override;
+ longlong val_int_result() override;
+ String *str_result(String* tmp) override;
+ my_decimal *val_decimal_result(my_decimal *val) override;
+ bool val_bool_result() override;
+
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_direct_view_ref>(thd, this); }
+ Item *field_transformer_for_having_pushdown(THD *, uchar *) override
+ { return this; }
+ Item *remove_item_direct_ref() override { return this; }
+};
+
+
+/*
+ Class for outer fields.
+ An object of this class is created when the select where the outer field was
+ resolved is a grouping one. After it has been fixed the ref field will point
+ to either an Item_ref or an Item_direct_ref object which will be used to
+ access the field.
+ See also comments for the fix_inner_refs() and the
+ Item_field::fix_outer_field() functions.
+*/
+
+class Item_sum;
+class Item_outer_ref :public Item_direct_ref
+{
+public:
+ Item *outer_ref;
+ /* The aggregate function under which this outer ref is used, if any. */
+ Item_sum *in_sum_func;
+ /*
+ TRUE <=> that the outer_ref is already present in the select list
+ of the outer select.
+ */
+ bool found_in_select_list;
+ bool found_in_group_by;
+ Item_outer_ref(THD *thd, Name_resolution_context *context_arg,
+ Item_field *outer_field_arg):
+ Item_direct_ref(thd, context_arg, 0, outer_field_arg->table_name,
+ outer_field_arg->field_name),
+ outer_ref(outer_field_arg), in_sum_func(0),
+ found_in_select_list(0), found_in_group_by(0)
+ {
+ ref= &outer_ref;
+ set_properties();
+ fixed= 0; /* reset flag set in set_properties() */
+ }
+ Item_outer_ref(THD *thd, Name_resolution_context *context_arg, Item **item,
+ const LEX_CSTRING &table_name_arg, LEX_CSTRING &field_name_arg,
+ bool alias_name_used_arg):
+ Item_direct_ref(thd, context_arg, item, table_name_arg, field_name_arg,
+ alias_name_used_arg),
+ outer_ref(0), in_sum_func(0), found_in_select_list(1), found_in_group_by(0)
+ {}
+ void save_in_result_field(bool no_conversions) override
+ {
+ outer_ref->save_org_in_field(result_field, NULL);
+ }
+ bool fix_fields(THD *, Item **) override;
+ void fix_after_pullout(st_select_lex *new_parent, Item **ref, bool merge)
+ override;
+ table_map used_tables() const override
+ {
+ return (*ref)->const_item() ? 0 : OUTER_REF_TABLE_BIT;
+ }
+ table_map not_null_tables() const override { return 0; }
+ Ref_Type ref_type() override { return OUTER_REF; }
+ bool check_inner_refs_processor(void * arg) override;
+};
+
+
+class Item_in_subselect;
+
+
+/*
+ An object of this class:
+ - Converts val_XXX() calls to ref->val_XXX_result() calls, like Item_ref.
+ - Sets owner->was_null=TRUE if it has returned a NULL value from any
+ val_XXX() function. This allows to inject an Item_ref_null_helper
+ object into subquery and then check if the subquery has produced a row
+ with NULL value.
+*/
+
+class Item_ref_null_helper: public Item_ref
+{
+protected:
+ Item_in_subselect* owner;
+public:
+ Item_ref_null_helper(THD *thd, Name_resolution_context *context_arg,
+ Item_in_subselect* master, Item **item,
+ const LEX_CSTRING &table_name_arg,
+ const LEX_CSTRING &field_name_arg):
+ Item_ref(thd, context_arg, item, table_name_arg, field_name_arg),
+ owner(master) {}
+ void save_val(Field *to) override;
+ double val_real() override;
+ longlong val_int() override;
+ String* val_str(String* s) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool val_bool() override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ bool val_native(THD *thd, Native *to) override;
+ void print(String *str, enum_query_type query_type) override;
+ table_map used_tables() const override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_ref_null_helper>(thd, this); }
+};
+
+/*
+ The following class is used to optimize comparing of date and bigint columns
+ We need to save the original item ('ref') to be able to call
+ ref->save_in_field(). This is used to create index search keys.
+
+ An instance of Item_int_with_ref may have signed or unsigned integer value.
+
+*/
+
+class Item_int_with_ref :public Item_int
+{
+ Item *ref;
+public:
+ Item_int_with_ref(THD *thd, longlong i, Item *ref_arg, bool unsigned_arg):
+ Item_int(thd, i), ref(ref_arg)
+ {
+ unsigned_flag= unsigned_arg;
+ }
+ int save_in_field(Field *field, bool no_conversions) override
+ {
+ return ref->save_in_field(field, no_conversions);
+ }
+ Item *clone_item(THD *thd) override;
+ Item *real_item() override { return ref; }
+};
+
+#ifdef MYSQL_SERVER
+#include "item_sum.h"
+#include "item_func.h"
+#include "item_row.h"
+#include "item_cmpfunc.h"
+#include "item_strfunc.h"
+#include "item_timefunc.h"
+#include "item_subselect.h"
+#include "item_xmlfunc.h"
+#include "item_jsonfunc.h"
+#include "item_create.h"
+#include "item_vers.h"
+#endif
+
+/**
+ Base class to implement typed value caching Item classes
+
+ Item_copy_ classes are very similar to the corresponding Item_
+ classes (e.g. Item_copy_string is similar to Item_string) but they add
+ the following additional functionality to Item_ :
+ 1. Nullability
+ 2. Possibility to store the value not only on instantiation time,
+ but also later.
+ Item_copy_ classes are a functionality subset of Item_cache_
+ classes, as e.g. they don't support comparisons with the original Item
+ as Item_cache_ classes do.
+ Item_copy_ classes are used in GROUP BY calculation.
+ TODO: Item_copy should be made an abstract interface and Item_copy_
+ classes should inherit both the respective Item_ class and the interface.
+ Ideally we should drop Item_copy_ classes altogether and merge
+ their functionality to Item_cache_ (and these should be made to inherit
+ from Item_).
+*/
+
+class Item_copy :public Item,
+ public Type_handler_hybrid_field_type
+{
+protected:
+
+ /**
+ Type_handler_hybrid_field_type is used to
+ store the type of the resulting field that would be used to store the data
+ in the cache. This is to avoid calls to the original item.
+ */
+
+ /** The original item that is copied */
+ Item *item;
+
+ /**
+ Constructor of the Item_copy class
+
+ stores metadata information about the original class as well as a
+ pointer to it.
+ */
+ Item_copy(THD *thd, Item *i): Item(thd)
+ {
+ DBUG_ASSERT(i->is_fixed());
+ item= i;
+ null_value=maybe_null=item->maybe_null;
+ Type_std_attributes::set(item);
+ name= item->name;
+ set_handler(item->type_handler());
+ }
+
+public:
+
+ /**
+ Update the cache with the value of the original item
+
+ This is the method that updates the cached value.
+ It must be explicitly called by the user of this class to store the value
+ of the original item in the cache.
+ */
+ virtual void copy() = 0;
+
+ Item *get_item() { return item; }
+ /** All of the subclasses should have the same type tag */
+ Type type() const override { return COPY_STR_ITEM; }
+
+ const Type_handler *type_handler() const override
+ { return Type_handler_hybrid_field_type::type_handler(); }
+
+ Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+ DBUG_ASSERT(0);
+ return NULL;
+ }
+ void make_send_field(THD *thd, Send_field *field) override
+ { item->make_send_field(thd, field); }
+ table_map used_tables() const override { return (table_map) 1L; }
+ bool const_item() const override { return false; }
+ bool is_null() override { return null_value; }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function("copy", arg, VCOL_IMPOSSIBLE);
+ }
+
+ /*
+ Override the methods below as pure virtual to make sure all the
+ sub-classes implement them.
+ */
+
+ String *val_str(String*) override = 0;
+ my_decimal *val_decimal(my_decimal *) override = 0;
+ double val_real() override = 0;
+ longlong val_int() override = 0;
+ int save_in_field(Field *field, bool no_conversions) override = 0;
+ bool walk(Item_processor processor, bool walk_subquery, void *args) override
+ {
+ return (item->walk(processor, walk_subquery, args)) ||
+ (this->*processor)(args);
+ }
+};
+
+/**
+ Implementation of a string cache.
+
+ Uses Item::str_value for storage
+*/
+class Item_copy_string : public Item_copy
+{
+public:
+ Item_copy_string(THD *thd, Item *item_arg): Item_copy(thd, item_arg) {}
+
+ String *val_str(String*) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ double val_real() override;
+ longlong val_int() override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ { return get_date_from_string(thd, ltime, fuzzydate); }
+ void copy() override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_copy_string>(thd, this); }
+};
+
+
+/**
+ We need a separate class Item_copy_timestamp because
+ TIMESTAMP->string->TIMESTAMP conversion is not round trip safe
+ near the DST change, e.g. '2010-10-31 02:25:26' can mean:
+ - my_time_t(1288477526) - summer time in Moscow
+ - my_time_t(1288481126) - winter time in Moscow, one hour later
+*/
+class Item_copy_timestamp: public Item_copy
+{
+ Timestamp_or_zero_datetime m_value;
+ bool sane() const { return !null_value || m_value.is_zero_datetime(); }
+public:
+ Item_copy_timestamp(THD *thd, Item *arg): Item_copy(thd, arg) { }
+ const Type_handler *type_handler() const override
+ { return &type_handler_timestamp2; }
+ void copy() override
+ {
+ Timestamp_or_zero_datetime_native_null tmp(current_thd, item, false);
+ null_value= tmp.is_null();
+ m_value= tmp.is_null() ? Timestamp_or_zero_datetime() :
+ Timestamp_or_zero_datetime(tmp);
+ }
+ int save_in_field(Field *field, bool) override
+ {
+ DBUG_ASSERT(sane());
+ if (null_value)
+ return set_field_to_null(field);
+ Timestamp_or_zero_datetime_native native(m_value, decimals);
+ return native.save_in_field(field, decimals);
+ }
+ longlong val_int() override
+ {
+ DBUG_ASSERT(sane());
+ return null_value ? 0 :
+ m_value.to_datetime(current_thd).to_longlong();
+ }
+ double val_real() override
+ {
+ DBUG_ASSERT(sane());
+ return null_value ? 0e0 :
+ m_value.to_datetime(current_thd).to_double();
+ }
+ String *val_str(String *to) override
+ {
+ DBUG_ASSERT(sane());
+ return null_value ? NULL :
+ m_value.to_datetime(current_thd).to_string(to, decimals);
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ DBUG_ASSERT(sane());
+ return null_value ? NULL :
+ m_value.to_datetime(current_thd).to_decimal(to);
+ }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ {
+ DBUG_ASSERT(sane());
+ bool res= m_value.to_TIME(thd, ltime, fuzzydate);
+ DBUG_ASSERT(!res);
+ return null_value || res;
+ }
+ bool val_native(THD *thd, Native *to) override
+ {
+ DBUG_ASSERT(sane());
+ return null_value || m_value.to_native(to, decimals);
+ }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_copy_timestamp>(thd, this); }
+};
+
+
+/*
+ Cached_item_XXX objects are not exactly caches. They do the following:
+
+ Each Cached_item_XXX object has
+ - its source item
+ - saved value of the source item
+ - cmp() method that compares the saved value with the current value of the
+ source item, and if they were not equal saves item's value into the saved
+ value.
+
+ TODO: add here:
+ - a way to save the new value w/o comparison
+ - a way to do less/equal/greater comparison
+*/
+
+class Cached_item :public Sql_alloc
+{
+public:
+ bool null_value;
+ Cached_item() :null_value(0) {}
+ /*
+ Compare the cached value with the source value. If not equal, copy
+ the source value to the cache.
+ @return
+ true - Not equal
+ false - Equal
+ */
+ virtual bool cmp(void)=0;
+
+ /* Compare the cached value with the source value, without copying */
+ virtual int cmp_read_only()=0;
+
+ virtual ~Cached_item(); /*line -e1509 */
+};
+
+class Cached_item_item : public Cached_item
+{
+protected:
+ Item *item;
+
+ Cached_item_item(Item *arg) : item(arg) {}
+public:
+ void fetch_value_from(Item *new_item)
+ {
+ Item *save= item;
+ item= new_item;
+ cmp();
+ item= save;
+ }
+};
+
+class Cached_item_str :public Cached_item_item
+{
+ uint32 value_max_length;
+ String value,tmp_value;
+public:
+ Cached_item_str(THD *thd, Item *arg);
+ bool cmp() override;
+ int cmp_read_only() override;
+ ~Cached_item_str(); // Deallocate String:s
+};
+
+
+class Cached_item_real :public Cached_item_item
+{
+ double value;
+public:
+ Cached_item_real(Item *item_par) :Cached_item_item(item_par),value(0.0) {}
+ bool cmp() override;
+ int cmp_read_only() override;
+};
+
+class Cached_item_int :public Cached_item_item
+{
+ longlong value;
+public:
+ Cached_item_int(Item *item_par) :Cached_item_item(item_par),value(0) {}
+ bool cmp() override;
+ int cmp_read_only() override;
+};
+
+
+class Cached_item_decimal :public Cached_item_item
+{
+ my_decimal value;
+public:
+ Cached_item_decimal(Item *item_par);
+ bool cmp() override;
+ int cmp_read_only() override;
+};
+
+class Cached_item_field :public Cached_item
+{
+ uchar *buff;
+ Field *field;
+ uint length;
+
+public:
+ Cached_item_field(THD *thd, Field *arg_field): field(arg_field)
+ {
+ field= arg_field;
+ /* TODO: take the memory allocation below out of the constructor. */
+ buff= (uchar*) thd_calloc(thd, length= field->pack_length());
+ }
+ bool cmp() override;
+ int cmp_read_only() override;
+};
+
+class Item_default_value : public Item_field
+{
+ bool vcol_assignment_ok;
+ void calculate();
+public:
+ Item *arg= nullptr;
+ Field *cached_field= nullptr;
+ Item_default_value(THD *thd, Name_resolution_context *context_arg, Item *a,
+ bool vcol_assignment_arg)
+ : Item_field(thd, context_arg),
+ vcol_assignment_ok(vcol_assignment_arg), arg(a) {}
+ Type type() const override { return DEFAULT_VALUE_ITEM; }
+ bool eq(const Item *item, bool binary_cmp) const override;
+ bool fix_fields(THD *, Item **) override;
+ void cleanup() override;
+ void print(String *str, enum_query_type query_type) override;
+ String *val_str(String *str) override;
+ double val_real() override;
+ longlong val_int() override;
+ my_decimal *val_decimal(my_decimal *decimal_value) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime,date_mode_t fuzzydate) override;
+ bool val_native(THD *thd, Native *to) override;
+ bool val_native_result(THD *thd, Native *to) override;
+
+ /* Result variants */
+ double val_result() override;
+ longlong val_int_result() override;
+ String *str_result(String* tmp) override;
+ my_decimal *val_decimal_result(my_decimal *val) override;
+ bool val_bool_result() override;
+ bool is_null_result() override;
+ bool get_date_result(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+ override;
+
+ bool send(Protocol *protocol, st_value *buffer) override;
+ int save_in_field(Field *field_arg, bool no_conversions) override;
+ bool save_in_param(THD *, Item_param *param) override
+ {
+ // It should not be possible to have "EXECUTE .. USING DEFAULT(a)"
+ DBUG_ASSERT(0);
+ param->set_default();
+ return false;
+ }
+ table_map used_tables() const override;
+ void update_used_tables() override
+ {
+ if (field && field->default_value)
+ field->default_value->expr->update_used_tables();
+ }
+ bool vcol_assignment_allowed_value() const override
+ { return vcol_assignment_ok; }
+ Field *get_tmp_table_field() override { return nullptr; }
+ Item *get_tmp_table_item(THD *) override { return this; }
+ Item_field *field_for_view_update() override { return nullptr; }
+ bool update_vcol_processor(void *) override { return false; }
+ bool check_func_default_processor(void *) override { return true; }
+
+ bool walk(Item_processor processor, bool walk_subquery, void *args) override
+ {
+ return (arg && arg->walk(processor, walk_subquery, args)) ||
+ (this->*processor)(args);
+ }
+
+ Item *transform(THD *thd, Item_transformer transformer, uchar *args)
+ override;
+ Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override;
+};
+
+
+class Item_contextually_typed_value_specification: public Item
+{
+public:
+ Item_contextually_typed_value_specification(THD *thd) :Item(thd)
+ { }
+ Type type() const override { return CONTEXTUALLY_TYPED_VALUE_ITEM; }
+ bool vcol_assignment_allowed_value() const override { return true; }
+ bool eq(const Item *item, bool binary_cmp) const override { return false; }
+ bool is_evaluable_expression() const override { return false; }
+ Field *create_tmp_field_ex(MEM_ROOT *,
+ TABLE *, Tmp_field_src *,
+ const Tmp_field_param *) override
+ {
+ DBUG_ASSERT(0);
+ return NULL;
+ }
+ String *val_str(String *str) override
+ {
+ DBUG_ASSERT(0); // never should be called
+ null_value= true;
+ return 0;
+ }
+ double val_real() override
+ {
+ DBUG_ASSERT(0); // never should be called
+ null_value= true;
+ return 0.0;
+ }
+ longlong val_int() override
+ {
+ DBUG_ASSERT(0); // never should be called
+ null_value= true;
+ return 0;
+ }
+ my_decimal *val_decimal(my_decimal *) override
+ {
+ DBUG_ASSERT(0); // never should be called
+ null_value= true;
+ return 0;
+ }
+ bool get_date(THD *, MYSQL_TIME *, date_mode_t) override
+ {
+ DBUG_ASSERT(0); // never should be called
+ return null_value= true;
+ }
+ bool send(Protocol *, st_value *) override
+ {
+ DBUG_ASSERT(0);
+ return true;
+ }
+ const Type_handler *type_handler() const override
+ {
+ DBUG_ASSERT(0);
+ return &type_handler_null;
+ }
+};
+
+
+/*
+ <default specification> ::= DEFAULT
+*/
+class Item_default_specification:
+ public Item_contextually_typed_value_specification
+{
+public:
+ Item_default_specification(THD *thd)
+ :Item_contextually_typed_value_specification(thd)
+ { }
+ void print(String *str, enum_query_type) override
+ {
+ str->append(STRING_WITH_LEN("default"));
+ }
+ int save_in_field(Field *field_arg, bool) override
+ {
+ return field_arg->save_in_field_default_value(false);
+ }
+ bool save_in_param(THD *, Item_param *param) override
+ {
+ param->set_default();
+ return false;
+ }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_default_specification>(thd, this); }
+};
+
+
+/**
+ This class is used as bulk parameter INGNORE representation.
+
+ It just do nothing when assigned to a field
+
+ This is a non-standard MariaDB extension.
+*/
+
+class Item_ignore_specification:
+ public Item_contextually_typed_value_specification
+{
+public:
+ Item_ignore_specification(THD *thd)
+ :Item_contextually_typed_value_specification(thd)
+ { }
+ void print(String *str, enum_query_type) override
+ {
+ str->append(STRING_WITH_LEN("ignore"));
+ }
+ int save_in_field(Field *field_arg, bool) override
+ {
+ return field_arg->save_in_field_ignore_value(false);
+ }
+ bool save_in_param(THD *, Item_param *param) override
+ {
+ param->set_ignore();
+ return false;
+ }
+
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_ignore_specification>(thd, this); }
+};
+
+
+/*
+ Item_insert_value -- an implementation of VALUES() function.
+ You can use the VALUES(col_name) function in the UPDATE clause
+ to refer to column values from the INSERT portion of the INSERT
+ ... UPDATE statement. In other words, VALUES(col_name) in the
+ UPDATE clause refers to the value of col_name that would be
+ inserted, had no duplicate-key conflict occurred.
+ In all other places this function returns NULL.
+*/
+
+class Item_insert_value : public Item_field
+{
+public:
+ Item *arg;
+ Item_insert_value(THD *thd, Name_resolution_context *context_arg, Item *a)
+ :Item_field(thd, context_arg),
+ arg(a) {}
+ bool eq(const Item *item, bool binary_cmp) const override;
+ bool fix_fields(THD *, Item **) override;
+ void print(String *str, enum_query_type query_type) override;
+ int save_in_field(Field *field_arg, bool no_conversions) override
+ {
+ return Item_field::save_in_field(field_arg, no_conversions);
+ }
+ Type type() const override { return INSERT_VALUE_ITEM; }
+ /*
+ We use RAND_TABLE_BIT to prevent Item_insert_value from
+ being treated as a constant and precalculated before execution
+ */
+ table_map used_tables() const override { return RAND_TABLE_BIT; }
+
+ Item_field *field_for_view_update() override { return nullptr; }
+
+ bool walk(Item_processor processor, bool walk_subquery, void *args) override
+ {
+ return arg->walk(processor, walk_subquery, args) ||
+ (this->*processor)(args);
+ }
+ bool check_partition_func_processor(void *) override { return true; }
+ bool update_vcol_processor(void *) override { return false; }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ return mark_unsupported_function("value()", arg, VCOL_IMPOSSIBLE);
+ }
+};
+
+
+class Table_triggers_list;
+
+/*
+ Represents NEW/OLD version of field of row which is
+ changed/read in trigger.
+
+ Note: For this item main part of actual binding to Field object happens
+ not during fix_fields() call (like for Item_field) but right after
+ parsing of trigger definition, when table is opened, with special
+ setup_field() call. On fix_fields() stage we simply choose one of
+ two Field instances representing either OLD or NEW version of this
+ field.
+*/
+class Item_trigger_field : public Item_field,
+ private Settable_routine_parameter
+{
+public:
+ /* Is this item represents row from NEW or OLD row ? */
+ enum row_version_type {OLD_ROW, NEW_ROW};
+ row_version_type row_version;
+ /* Next in list of all Item_trigger_field's in trigger */
+ Item_trigger_field *next_trg_field;
+ /* Index of the field in the TABLE::field array */
+ uint field_idx;
+ /* Pointer to Table_trigger_list object for table of this trigger */
+ Table_triggers_list *triggers;
+
+ Item_trigger_field(THD *thd, Name_resolution_context *context_arg,
+ row_version_type row_ver_arg,
+ const LEX_CSTRING &field_name_arg,
+ privilege_t priv, const bool ro)
+ :Item_field(thd, context_arg, field_name_arg),
+ row_version(row_ver_arg), field_idx((uint)-1), original_privilege(priv),
+ want_privilege(priv), table_grants(NULL), read_only (ro)
+ {}
+ void setup_field(THD *thd, TABLE *table, GRANT_INFO *table_grant_info);
+ Type type() const override { return TRIGGER_FIELD_ITEM; }
+ bool eq(const Item *item, bool binary_cmp) const override;
+ bool fix_fields(THD *, Item **) override;
+ void print(String *str, enum_query_type query_type) override;
+ table_map used_tables() const override { return (table_map)0L; }
+ Field *get_tmp_table_field() override { return nullptr; }
+ Item *copy_or_same(THD *) override { return this; }
+ Item *get_tmp_table_item(THD *thd) override { return copy_or_same(thd); }
+ void cleanup() override;
+
+private:
+ void set_required_privilege(bool rw) override;
+ bool set_value(THD *thd, sp_rcontext *ctx, Item **it) override;
+
+public:
+ Settable_routine_parameter *get_settable_routine_parameter() override
+ {
+ return read_only ? nullptr : this;
+ }
+
+ bool set_value(THD *thd, Item **it)
+ {
+ return set_value(thd, NULL, it);
+ }
+
+private:
+ /*
+ 'want_privilege' holds privileges required to perform operation on
+ this trigger field (SELECT_ACL if we are going to read it and
+ UPDATE_ACL if we are going to update it). It is initialized at
+ parse time but can be updated later if this trigger field is used
+ as OUT or INOUT parameter of stored routine (in this case
+ set_required_privilege() is called to appropriately update
+ want_privilege and cleanup() is responsible for restoring of
+ original want_privilege once parameter's value is updated).
+ */
+ privilege_t original_privilege;
+ privilege_t want_privilege;
+ GRANT_INFO *table_grants;
+ /*
+ Trigger field is read-only unless it belongs to the NEW row in a
+ BEFORE INSERT of BEFORE UPDATE trigger.
+ */
+ bool read_only;
+public:
+ bool unknown_splocal_processor(void *) override { return false; }
+ bool check_vcol_func_processor(void *arg) override;
+};
+
+
+/**
+ @todo
+ Implement the is_null() method for this class. Currently calling is_null()
+ on any Item_cache object resolves to Item::is_null(), which returns FALSE
+ for any value.
+*/
+
+class Item_cache: public Item,
+ public Type_handler_hybrid_field_type
+{
+protected:
+ Item *example;
+ /**
+ Field that this object will get value from. This is used by
+ index-based subquery engines to detect and remove the equality injected
+ by IN->EXISTS transformation.
+ */
+ Field *cached_field;
+ /*
+ TRUE <=> cache holds value of the last stored item (i.e actual value).
+ store() stores item to be cached and sets this flag to FALSE.
+ On the first call of val_xxx function if this flag is set to FALSE the
+ cache_value() will be called to actually cache value of saved item.
+ cache_value() will set this flag to TRUE.
+ */
+ bool value_cached;
+
+ table_map used_table_map;
+public:
+ /*
+ This is set if at least one of the values of a sub query is NULL
+ Item_cache_row returns this with null_inside().
+ For not row items, it's set to the value of null_value
+ It is set after cache_value() is called.
+ */
+ bool null_value_inside;
+
+ Item_cache(THD *thd):
+ Item(thd),
+ Type_handler_hybrid_field_type(&type_handler_string),
+ example(0), cached_field(0),
+ value_cached(0),
+ used_table_map(0)
+ {
+ maybe_null= 1;
+ null_value= 1;
+ null_value_inside= true;
+ }
+protected:
+ Item_cache(THD *thd, const Type_handler *handler):
+ Item(thd),
+ Type_handler_hybrid_field_type(handler),
+ example(0), cached_field(0),
+ value_cached(0),
+ used_table_map(0)
+ {
+ maybe_null= 1;
+ null_value= 1;
+ null_value_inside= true;
+ }
+
+public:
+ virtual bool allocate(THD *thd, uint i) { return 0; }
+ virtual bool setup(THD *thd, Item *item)
+ {
+ example= item;
+ Type_std_attributes::set(item);
+ if (item->type() == FIELD_ITEM)
+ cached_field= ((Item_field *)item)->field;
+ return 0;
+ };
+
+ void set_used_tables(table_map map) { used_table_map= map; }
+ table_map used_tables() const override { return used_table_map; }
+ Type type() const override { return CACHE_ITEM; }
+
+ const Type_handler *type_handler() const override
+ { return Type_handler_hybrid_field_type::type_handler(); }
+ Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+ return create_tmp_field_ex_simple(root, table, src, param);
+ }
+
+ virtual void keep_array() {}
+ void print(String *str, enum_query_type query_type) override;
+ bool eq_def(const Field *field)
+ {
+ return cached_field ? cached_field->eq_def (field) : FALSE;
+ }
+ bool eq(const Item *item, bool binary_cmp) const override
+ {
+ return this == item;
+ }
+ bool check_vcol_func_processor(void *arg) override
+ {
+ if (example)
+ {
+ Item::vcol_func_processor_result *res= (Item::vcol_func_processor_result*)arg;
+ example->check_vcol_func_processor(arg);
+ /*
+ Item_cache of a non-deterministic function requires re-fixing
+ even if the function itself doesn't (e.g. CURRENT_TIMESTAMP)
+ */
+ if (res->errors & VCOL_NOT_STRICTLY_DETERMINISTIC)
+ res->errors|= VCOL_SESSION_FUNC;
+ return false;
+ }
+ return mark_unsupported_function("cache", arg, VCOL_IMPOSSIBLE);
+ }
+ void cleanup() override
+ {
+ clear();
+ Item::cleanup();
+ }
+ /**
+ Check if saved item has a non-NULL value.
+ Will cache value of saved item if not already done.
+ @return TRUE if cached value is non-NULL.
+ */
+ bool has_value()
+ {
+ return (value_cached || cache_value()) && !null_value;
+ }
+
+ virtual void store(Item *item);
+ virtual Item *get_item() { return example; }
+ virtual bool cache_value()= 0;
+ bool basic_const_item() const override
+ { return example && example->basic_const_item(); }
+ virtual void clear() { null_value= TRUE; value_cached= FALSE; }
+ bool is_null() override { return !has_value(); }
+ bool is_expensive() override
+ {
+ if (value_cached)
+ return false;
+ return example->is_expensive();
+ }
+ bool is_expensive_processor(void *arg) override
+ {
+ DBUG_ASSERT(example);
+ if (value_cached)
+ return false;
+ return example->is_expensive_processor(arg);
+ }
+ virtual void set_null();
+ bool walk(Item_processor processor, bool walk_subquery, void *arg) override
+ {
+ if (arg == STOP_PTR)
+ return FALSE;
+ if (example && example->walk(processor, walk_subquery, arg))
+ return TRUE;
+ return (this->*processor)(arg);
+ }
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs) override;
+ void split_sum_func2_example(THD *thd, Ref_ptr_array ref_pointer_array,
+ List<Item> &fields, uint flags)
+ {
+ example->split_sum_func2(thd, ref_pointer_array, fields, &example, flags);
+ }
+ Item *get_example() const { return example; }
+
+ virtual Item *convert_to_basic_const_item(THD *thd) { return 0; };
+ Item *derived_field_transformer_for_having(THD *thd, uchar *) override
+ { return convert_to_basic_const_item(thd); }
+ Item *derived_field_transformer_for_where(THD *thd, uchar *) override
+ { return convert_to_basic_const_item(thd); }
+ Item *grouping_field_transformer_for_where(THD *thd, uchar *) override
+ { return convert_to_basic_const_item(thd); }
+ Item *in_subq_field_transformer_for_where(THD *thd, uchar *) override
+ { return convert_to_basic_const_item(thd); }
+ Item *in_subq_field_transformer_for_having(THD *thd, uchar *) override
+ { return convert_to_basic_const_item(thd); }
+};
+
+
+class Item_cache_int: public Item_cache
+{
+protected:
+ longlong value;
+public:
+ Item_cache_int(THD *thd, const Type_handler *handler):
+ Item_cache(thd, handler), value(0) {}
+
+ double val_real() override;
+ longlong val_int() override;
+ String* val_str(String *str) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ { return get_date_from_int(thd, ltime, fuzzydate); }
+ bool cache_value() override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ Item *convert_to_basic_const_item(THD *thd) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_int>(thd, this); }
+};
+
+
+class Item_cache_year: public Item_cache_int
+{
+public:
+ Item_cache_year(THD *thd, const Type_handler *handler)
+ :Item_cache_int(thd, handler) { }
+ bool get_date(THD *thd, MYSQL_TIME *to, date_mode_t mode)
+ {
+ return type_handler_year.Item_get_date_with_warn(thd, this, to, mode);
+ }
+};
+
+
+class Item_cache_temporal: public Item_cache_int
+{
+protected:
+ Item_cache_temporal(THD *thd, const Type_handler *handler);
+public:
+ bool cache_value() override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ bool setup(THD *thd, Item *item) override
+ {
+ if (Item_cache_int::setup(thd, item))
+ return true;
+ set_if_smaller(decimals, TIME_SECOND_PART_DIGITS);
+ return false;
+ }
+ void store_packed(longlong val_arg, Item *example);
+ /*
+ Having a clone_item method tells optimizer that this object
+ is a constant and need not be optimized further.
+ Important when storing packed datetime values.
+ */
+ Item *clone_item(THD *thd) override;
+ Item *convert_to_basic_const_item(THD *thd) override;
+ virtual Item *make_literal(THD *) =0;
+};
+
+
+class Item_cache_time: public Item_cache_temporal
+{
+public:
+ Item_cache_time(THD *thd)
+ :Item_cache_temporal(thd, &type_handler_time2) { }
+ bool cache_value() override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_time>(thd, this); }
+ Item *make_literal(THD *) override;
+ longlong val_datetime_packed(THD *thd) override
+ {
+ Datetime::Options_cmp opt(thd);
+ return has_value() ? Datetime(thd, this, opt).to_packed() : 0;
+ }
+ longlong val_time_packed(THD *) override
+ {
+ return has_value() ? value : 0;
+ }
+ longlong val_int() override
+ {
+ return has_value() ? Time(this).to_longlong() : 0;
+ }
+ double val_real() override
+ {
+ return has_value() ? Time(this).to_double() : 0;
+ }
+ String *val_str(String *to) override
+ {
+ return has_value() ? Time(this).to_string(to, decimals) : NULL;
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return has_value() ? Time(this).to_decimal(to) : NULL;
+ }
+ bool val_native(THD *thd, Native *to) override
+ {
+ return has_value() ? Time(thd, this).to_native(to, decimals) : true;
+ }
+};
+
+
+class Item_cache_datetime: public Item_cache_temporal
+{
+public:
+ Item_cache_datetime(THD *thd)
+ :Item_cache_temporal(thd, &type_handler_datetime2) { }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_datetime>(thd, this); }
+ Item *make_literal(THD *) override;
+ longlong val_datetime_packed(THD *) override
+ {
+ return has_value() ? value : 0;
+ }
+ longlong val_time_packed(THD *thd) override
+ {
+ return Time(thd, this, Time::Options_cmp(thd)).to_packed();
+ }
+ longlong val_int() override
+ {
+ return has_value() ? Datetime(this).to_longlong() : 0;
+ }
+ double val_real() override
+ {
+ return has_value() ? Datetime(this).to_double() : 0;
+ }
+ String *val_str(String *to) override
+ {
+ return has_value() ? Datetime(this).to_string(to, decimals) : NULL;
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return has_value() ? Datetime(this).to_decimal(to) : NULL;
+ }
+};
+
+
+class Item_cache_date: public Item_cache_temporal
+{
+public:
+ Item_cache_date(THD *thd)
+ :Item_cache_temporal(thd, &type_handler_newdate) { }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_date>(thd, this); }
+ Item *make_literal(THD *) override;
+ longlong val_datetime_packed(THD *) override
+ {
+ return has_value() ? value : 0;
+ }
+ longlong val_time_packed(THD *thd) override
+ {
+ return Time(thd, this, Time::Options_cmp(thd)).to_packed();
+ }
+ longlong val_int() override
+ { return has_value() ? Date(this).to_longlong() : 0; }
+ double val_real() override
+ { return has_value() ? Date(this).to_double() : 0; }
+ String *val_str(String *to) override
+ {
+ return has_value() ? Date(this).to_string(to) : NULL;
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return has_value() ? Date(this).to_decimal(to) : NULL;
+ }
+};
+
+
+class Item_cache_timestamp: public Item_cache
+{
+ Timestamp_or_zero_datetime_native m_native;
+ Datetime to_datetime(THD *thd);
+public:
+ Item_cache_timestamp(THD *thd)
+ :Item_cache(thd, &type_handler_timestamp2) { }
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_timestamp>(thd, this); }
+ bool cache_value() override;
+ String* val_str(String *to) override
+ {
+ return to_datetime(current_thd).to_string(to, decimals);
+ }
+ my_decimal *val_decimal(my_decimal *to) override
+ {
+ return to_datetime(current_thd).to_decimal(to);
+ }
+ longlong val_int() override
+ {
+ return to_datetime(current_thd).to_longlong();
+ }
+ double val_real() override
+ {
+ return to_datetime(current_thd).to_double();
+ }
+ longlong val_datetime_packed(THD *thd) override
+ {
+ return to_datetime(thd).to_packed();
+ }
+ longlong val_time_packed(THD *) override
+ {
+ DBUG_ASSERT(0);
+ return 0;
+ }
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ int save_in_field(Field *field, bool no_conversions) override;
+ bool val_native(THD *thd, Native *to) override;
+};
+
+
+class Item_cache_real: public Item_cache
+{
+protected:
+ double value;
+public:
+ Item_cache_real(THD *thd, const Type_handler *h)
+ :Item_cache(thd, h),
+ value(0)
+ {}
+ double val_real() override;
+ longlong val_int() override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ { return get_date_from_real(thd, ltime, fuzzydate); }
+ bool cache_value() override;
+ Item *convert_to_basic_const_item(THD *thd) override;
+};
+
+
+class Item_cache_double: public Item_cache_real
+{
+public:
+ Item_cache_double(THD *thd)
+ :Item_cache_real(thd, &type_handler_double)
+ { }
+ String* val_str(String *str);
+ Item *get_copy(THD *thd)
+ { return get_item_copy<Item_cache_double>(thd, this); }
+};
+
+
+class Item_cache_float: public Item_cache_real
+{
+public:
+ Item_cache_float(THD *thd)
+ :Item_cache_real(thd, &type_handler_float)
+ { }
+ String* val_str(String *str);
+ Item *get_copy(THD *thd)
+ { return get_item_copy<Item_cache_float>(thd, this); }
+};
+
+
+class Item_cache_decimal: public Item_cache
+{
+protected:
+ my_decimal decimal_value;
+public:
+ Item_cache_decimal(THD *thd): Item_cache(thd, &type_handler_newdecimal) {}
+
+ double val_real() override;
+ longlong val_int() override;
+ String* val_str(String *str) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *to, date_mode_t mode) override
+ {
+ return decimal_to_datetime_with_warn(thd, VDec(this).ptr(), to, mode,
+ NULL, NULL);
+ }
+ bool cache_value() override;
+ Item *convert_to_basic_const_item(THD *thd) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_decimal>(thd, this); }
+};
+
+
+class Item_cache_str: public Item_cache
+{
+ char buffer[STRING_BUFFER_USUAL_SIZE];
+ String *value, value_buff;
+ bool is_varbinary;
+
+public:
+ Item_cache_str(THD *thd, const Item *item):
+ Item_cache(thd, item->type_handler()), value(0),
+ is_varbinary(item->type() == FIELD_ITEM &&
+ Item_cache_str::field_type() == MYSQL_TYPE_VARCHAR &&
+ !((const Item_field *) item)->field->has_charset())
+ {
+ collation.set(const_cast<DTCollation&>(item->collation));
+ }
+ double val_real() override;
+ longlong val_int() override;
+ String* val_str(String *) override;
+ my_decimal *val_decimal(my_decimal *) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ { return get_date_from_string(thd, ltime, fuzzydate); }
+ CHARSET_INFO *charset() const { return value->charset(); };
+ int save_in_field(Field *field, bool no_conversions) override;
+ bool cache_value() override;
+ Item *convert_to_basic_const_item(THD *thd) override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_str>(thd, this); }
+};
+
+
+class Item_cache_str_for_nullif: public Item_cache_str
+{
+public:
+ Item_cache_str_for_nullif(THD *thd, const Item *item)
+ :Item_cache_str(thd, item)
+ { }
+ Item *safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+ {
+ /**
+ Item_cache_str::safe_charset_converter() returns a new Item_cache
+ with Item_func_conv_charset installed on "example". The original
+ Item_cache is not referenced (neither directly nor recursively)
+ from the result of Item_cache_str::safe_charset_converter().
+
+ For NULLIF() purposes we need a different behavior:
+ we need a new instance of Item_func_conv_charset,
+ with the original Item_cache referenced in args[0]. See MDEV-9181.
+ */
+ return Item::safe_charset_converter(thd, tocs);
+ }
+ Item *get_copy(THD *thd)
+ { return get_item_copy<Item_cache_str_for_nullif>(thd, this); }
+};
+
+
+class Item_cache_row: public Item_cache
+{
+ Item_cache **values;
+ uint item_count;
+ bool save_array;
+public:
+ Item_cache_row(THD *thd):
+ Item_cache(thd), values(0), item_count(2),
+ save_array(0) {}
+
+ /*
+ 'allocate' used only in row transformer, to preallocate space for row
+ cache.
+ */
+ bool allocate(THD *thd, uint num) override;
+ /*
+ 'setup' is needed only by row => it not called by simple row subselect
+ (only by IN subselect (in subselect optimizer))
+ */
+ bool setup(THD *thd, Item *item) override;
+ void store(Item *item) override;
+ void illegal_method_call(const char *);
+ void make_send_field(THD *, Send_field *) override
+ {
+ illegal_method_call("make_send_field");
+ };
+ double val_real() override
+ {
+ illegal_method_call("val");
+ return 0;
+ };
+ longlong val_int() override
+ {
+ illegal_method_call("val_int");
+ return 0;
+ };
+ String *val_str(String *) override
+ {
+ illegal_method_call("val_str");
+ return nullptr;
+ };
+ my_decimal *val_decimal(my_decimal *) override
+ {
+ illegal_method_call("val_decimal");
+ return nullptr;
+ };
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override
+ {
+ illegal_method_call("val_decimal");
+ return true;
+ }
+
+ uint cols() const override { return item_count; }
+ Item *element_index(uint i) override { return values[i]; }
+ Item **addr(uint i) override { return (Item **) (values + i); }
+ bool check_cols(uint c) override;
+ bool null_inside() override;
+ void bring_value() override;
+ void keep_array() override { save_array= 1; }
+ void cleanup() override
+ {
+ DBUG_ENTER("Item_cache_row::cleanup");
+ Item_cache::cleanup();
+ if (save_array)
+ bzero(values, item_count*sizeof(Item**));
+ else
+ values= 0;
+ DBUG_VOID_RETURN;
+ }
+ bool cache_value() override;
+ void set_null() override;
+ Item *get_copy(THD *thd) override
+ { return get_item_copy<Item_cache_row>(thd, this); }
+};
+
+
+/*
+ Item_type_holder used to store type. name, length of Item for UNIONS &
+ derived tables.
+
+ Item_type_holder do not need cleanup() because its time of live limited by
+ single SP/PS execution.
+*/
+class Item_type_holder: public Item,
+ public Type_handler_hybrid_field_type
+{
+protected:
+ const TYPELIB *enum_set_typelib;
+public:
+ Item_type_holder(THD *thd, Item *item)
+ :Item(thd, item),
+ Type_handler_hybrid_field_type(item->real_type_handler()),
+ enum_set_typelib(0)
+ {
+ DBUG_ASSERT(item->is_fixed());
+ maybe_null= item->maybe_null;
+ }
+ Item_type_holder(THD *thd,
+ Item *item,
+ const Type_handler *handler,
+ const Type_all_attributes *attr,
+ bool maybe_null_arg)
+ :Item(thd),
+ Type_handler_hybrid_field_type(handler),
+ enum_set_typelib(attr->get_typelib())
+ {
+ name= item->name;
+ Type_std_attributes::set(*attr);
+ maybe_null= maybe_null_arg;
+ common_flags= item->common_flags;
+ }
+
+ const Type_handler *type_handler() const override
+ {
+ return Type_handler_hybrid_field_type::type_handler()->
+ type_handler_for_item_field();
+ }
+ const Type_handler *real_type_handler() const override
+ {
+ return Type_handler_hybrid_field_type::type_handler();
+ }
+
+ Type type() const override { return TYPE_HOLDER; }
+ const TYPELIB *get_typelib() const override { return enum_set_typelib; }
+ /*
+ When handling a query like this:
+ VALUES ('') UNION VALUES( _utf16 0x0020 COLLATE utf16_bin);
+ Item_type_holder can be passed to
+ Type_handler_xxx::Item_hybrid_func_fix_attributes()
+ We don't want the latter to perform character set conversion of a
+ Item_type_holder by calling its val_str(), which calls DBUG_ASSERT(0).
+ Let's override const_item() and is_expensive() to avoid this.
+ Note, Item_hybrid_func_fix_attributes() could probably
+ have a new argument to distinguish what we need:
+ - (a) aggregate data type attributes only
+ - (b) install converters after attribute aggregation
+ So st_select_lex_unit::join_union_type_attributes() could
+ ask it to do (a) only, without (b).
+ */
+ bool const_item() const override { return false; }
+ bool is_expensive() override { return true; }
+ double val_real() override;
+ longlong val_int() override;
+ my_decimal *val_decimal(my_decimal *) override;
+ String *val_str(String*) override;
+ bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate) override;
+ Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+ const Tmp_field_param *param) override
+ {
+ return Item_type_holder::real_type_handler()->
+ make_and_init_table_field(root, &name, Record_addr(maybe_null),
+ *this, table);
+ }
+ Item* get_copy(THD *) override { return nullptr; }
+
+};
+
+
+class st_select_lex;
+void mark_select_range_as_dependent(THD *thd,
+ st_select_lex *last_select,
+ st_select_lex *current_sel,
+ Field *found_field, Item *found_item,
+ Item_ident *resolved_item,
+ bool suppress_warning_output);
+
+extern Cached_item *new_Cached_item(THD *thd, Item *item,
+ bool pass_through_ref);
+extern Item_result item_cmp_type(Item_result a,Item_result b);
+extern void resolve_const_item(THD *thd, Item **ref, Item *cmp_item);
+extern int stored_field_cmp_to_item(THD *thd, Field *field, Item *item);
+
+extern const String my_null_string;
+
+/**
+ Interface for Item iterator
+*/
+
+class Item_iterator
+{
+public:
+ /**
+ Shall set this iterator to the position before the first item
+
+ @note
+ This method also may perform some other initialization actions like
+ allocation of certain resources.
+ */
+ virtual void open()= 0;
+ /**
+ Shall return the next Item (or NULL if there is no next item) and
+ move pointer to position after it.
+ */
+ virtual Item *next()= 0;
+ /**
+ Shall force iterator to free resources (if it holds them)
+
+ @note
+ One should not use the iterator without open() call after close()
+ */
+ virtual void close()= 0;
+
+ virtual ~Item_iterator() {}
+};
+
+
+/**
+ Item iterator over List_iterator_fast for Item references
+*/
+
+class Item_iterator_ref_list: public Item_iterator
+{
+ List_iterator<Item*> list;
+public:
+ Item_iterator_ref_list(List_iterator<Item*> &arg_list):
+ list(arg_list) {}
+ void open() { list.rewind(); }
+ Item *next() { return *(list++); }
+ void close() {}
+};
+
+
+/**
+ Item iterator over List_iterator_fast for Items
+*/
+
+class Item_iterator_list: public Item_iterator
+{
+ List_iterator<Item> list;
+public:
+ Item_iterator_list(List_iterator<Item> &arg_list):
+ list(arg_list) {}
+ void open() { list.rewind(); }
+ Item *next() { return (list++); }
+ void close() {}
+};
+
+
+/**
+ Item iterator over Item interface for rows
+*/
+
+class Item_iterator_row: public Item_iterator
+{
+ Item *base_item;
+ uint current;
+public:
+ Item_iterator_row(Item *base) : base_item(base), current(0) {}
+ void open() { current= 0; }
+ Item *next()
+ {
+ if (current >= base_item->cols())
+ return NULL;
+ return base_item->element_index(current++);
+ }
+ void close() {}
+};
+
+
+/*
+ It's used in ::fix_fields() methods of LIKE and JSON_SEARCH
+ functions to handle the ESCAPE parameter.
+ This parameter is quite non-standard so the specific function.
+*/
+bool fix_escape_item(THD *thd, Item *escape_item, String *tmp_str,
+ bool escape_used_in_parsing, CHARSET_INFO *cmp_cs,
+ int *escape);
+
+inline bool Virtual_column_info::is_equal(const Virtual_column_info* vcol) const
+{
+ return type_handler() == vcol->type_handler()
+ && stored_in_db == vcol->is_stored()
+ && expr->eq(vcol->expr, true);
+}
+
+inline void Virtual_column_info::print(String* str)
+{
+ expr->print_for_table_def(str);
+}
+
+inline bool TABLE::mark_column_with_deps(Field *field)
+{
+ bool res;
+ if (!(res= bitmap_fast_test_and_set(read_set, field->field_index)))
+ {
+ if (field->vcol_info)
+ mark_virtual_column_deps(field);
+ }
+ return res;
+}
+
+inline bool TABLE::mark_virtual_column_with_deps(Field *field)
+{
+ bool res;
+ DBUG_ASSERT(field->vcol_info);
+ if (!(res= bitmap_fast_test_and_set(read_set, field->field_index)))
+ mark_virtual_column_deps(field);
+ return res;
+}
+
+inline void TABLE::mark_virtual_column_deps(Field *field)
+{
+ DBUG_ASSERT(field->vcol_info);
+ DBUG_ASSERT(field->vcol_info->expr);
+ field->vcol_info->expr->walk(&Item::register_field_in_read_map, 1, 0);
+}
+
+inline void TABLE::use_all_stored_columns()
+{
+ bitmap_set_all(read_set);
+ if (Field **vf= vfield)
+ for (; *vf; vf++)
+ bitmap_clear_bit(read_set, (*vf)->field_index);
+}
+
+#endif /* SQL_ITEM_INCLUDED */